{"version":3,"sources":["webpack://ic_demo_assets/./node_modules/base64-arraybuffer/lib/base64-arraybuffer.js","webpack://ic_demo_assets/./node_modules/base64-js/index.js","webpack://ic_demo_assets/./node_modules/bignumber.js/bignumber.js","webpack://ic_demo_assets/./node_modules/borc/node_modules/buffer/index.js","webpack://ic_demo_assets/./node_modules/borc/src/constants.js","webpack://ic_demo_assets/./node_modules/borc/src/decoder.asm.js","webpack://ic_demo_assets/./node_modules/borc/src/decoder.js","webpack://ic_demo_assets/./node_modules/borc/src/diagnose.js","webpack://ic_demo_assets/./node_modules/borc/src/encoder.js","webpack://ic_demo_assets/./node_modules/borc/src/index.js","webpack://ic_demo_assets/./node_modules/borc/src/simple.js","webpack://ic_demo_assets/./node_modules/borc/src/tagged.js","webpack://ic_demo_assets/./node_modules/borc/src/utils.js","webpack://ic_demo_assets/./node_modules/buffer-pipe/index.js","webpack://ic_demo_assets/./node_modules/buffer/index.js","webpack://ic_demo_assets/./node_modules/ieee754/index.js","webpack://ic_demo_assets/./node_modules/iso-url/index.js","webpack://ic_demo_assets/./node_modules/iso-url/src/relative.js","webpack://ic_demo_assets/./node_modules/iso-url/src/url-browser.js","webpack://ic_demo_assets/./node_modules/js-sha256/src/sha256.js","webpack://ic_demo_assets/./node_modules/process/browser.js","webpack://ic_demo_assets/./node_modules/safe-buffer/index.js","webpack://ic_demo_assets/./node_modules/simple-cbor/src/index.js","webpack://ic_demo_assets/./node_modules/simple-cbor/src/serializer.js","webpack://ic_demo_assets/./node_modules/simple-cbor/src/value.js","webpack://ic_demo_assets/webpack/bootstrap","webpack://ic_demo_assets/webpack/runtime/amd options","webpack://ic_demo_assets/webpack/runtime/compat get default export","webpack://ic_demo_assets/webpack/runtime/define property getters","webpack://ic_demo_assets/webpack/runtime/global","webpack://ic_demo_assets/webpack/runtime/hasOwnProperty shorthand","webpack://ic_demo_assets/webpack/runtime/make namespace object","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/agent/api.js","webpack://ic_demo_assets/./node_modules/@dfinity/principal/lib/esm/utils/base32.js","webpack://ic_demo_assets/./node_modules/@dfinity/principal/lib/esm/utils/getCrc.js","webpack://ic_demo_assets/./node_modules/@dfinity/principal/lib/esm/index.js","webpack://ic_demo_assets/./node_modules/@dfinity/principal/lib/esm/utils/sha224.js","webpack://ic_demo_assets/./node_modules/@dfinity/candid/lib/esm/utils/leb128.js","webpack://ic_demo_assets/./node_modules/@dfinity/candid/lib/esm/types.js","webpack://ic_demo_assets/./node_modules/@dfinity/candid/lib/esm/utils/hash.js","webpack://ic_demo_assets/./node_modules/@dfinity/candid/lib/esm/idl.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/request_id.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/auth.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/cbor.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/agent/http/transforms.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/agent/http/types.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/agent/http/index.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/agent/proxy.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/agent/index.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/canisters/management_idl.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/canisters/management.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/errors.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/vendor/bls/bls.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/utils/bls.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/certificate.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/polling/index.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/actor.js","webpack://ic_demo_assets/./node_modules/@dfinity/agent/lib/esm/polling/strategy.js","webpack://ic_demo_assets/./.dfx/ic/canisters/ic_demo/ic_demo.did.js","webpack://ic_demo_assets/./.dfx/ic/canisters/ic_demo/ic_demo.js","webpack://ic_demo_assets/./src/ic_demo_assets/src/index.js"],"names":["chars","lookup","Uint8Array","i","length","charCodeAt","arraybuffer","bytes","len","base64","substring","exports","encoded1","encoded2","encoded3","encoded4","bufferLength","p","ArrayBuffer","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","arr","Arr","_byteLength","curByte","revLookup","fromByteArray","uint8","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","join","Array","code","Error","indexOf","start","end","num","output","globalObject","BigNumber","isNumeric","mathceil","Math","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","n","coeffToString","a","s","z","j","r","slice","compare","x","y","b","xc","c","yc","k","e","l","intCheck","min","max","name","String","isOdd","toExponential","str","charAt","toFixedPoint","zs","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","prototype","constructor","toString","valueOf","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","prefix","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","ALPHABET","v","alphabet","caseChanged","isNum","this","_isBigNumber","test","replace","search","round","DEBUG","toUpperCase","toLowerCase","format","rm","id","c0","ne","maxOrMin","args","method","m","call","normalise","pop","sd","d","ni","rd","pows10","out","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","set","obj","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","arguments","lt","minimum","gt","random","dp","rand","Uint32Array","copy","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","reverse","sign","callerIsToString","pow","concat","multiply","base","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","isNaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","isFinite","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","t","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","split","g1","g2","intPart","fractionPart","isNeg","intDigits","substr","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","ieee754","customInspectSymbol","Symbol","Buffer","SlowBuffer","alloc","INSPECT_MAX_BYTES","K_MAX_LENGTH","createBuffer","RangeError","buf","Object","setPrototypeOf","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","string","encoding","isEncoding","actual","write","fromString","isView","arrayView","isInstance","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","isBuffer","checked","undefined","numberIsNaN","type","isArray","data","fromObject","toPrimitive","assertSize","size","array","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","val","dir","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","kMaxLength","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","console","error","defineProperty","enumerable","get","poolSize","fill","allocUnsafeSlow","_isBuffer","list","pos","swap16","swap32","swap64","toLocaleString","equals","inspect","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","_arr","ret","hexSliceLookupTable","checkOffset","ext","checkInt","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","INVALID_BASE64_RE","Infinity","leadSurrogate","base64clean","src","dst","table","i16","Bignumber","MT","POS_INT","NEG_INT","BYTE_STRING","UTF8_STRING","ARRAY","MAP","TAG","SIMPLE_FLOAT","DATE_STRING","DATE_EPOCH","POS_BIGINT","NEG_BIGINT","DECIMAL_FRAC","BIGFLOAT","BASE64URL_EXPECTED","BASE64_EXPECTED","BASE16_EXPECTED","CBOR","URI","BASE64URL","BASE64","REGEXP","MIME","NUMBYTES","ZERO","TWO","FOUR","EIGHT","INDEFINITE","SIMPLE","FALSE","TRUE","NULL","UNDEFINED","SYMS","PARENT","BREAK","STREAM","SHIFT32","SHIFT16","MAX_SAFE_HIGH","NEG_ONE","TEN","OBJECT","module","stdlib","foreign","heap","pushInt","pushInt32","pushInt32Neg","pushInt64","pushInt64Neg","pushFloat","pushFloatSingle","pushFloatDouble","pushTrue","pushFalse","pushUndefined","pushNull","pushInfinity","pushInfinityNeg","pushNaN","pushNaNNeg","pushArrayStart","pushArrayStartFixed","pushArrayStartFixed32","pushArrayStartFixed64","pushObjectStart","pushObjectStartFixed","pushObjectStartFixed32","pushObjectStartFixed64","pushByteString","pushByteStringStart","pushUtf8String","pushUtf8StringStart","pushSimpleUnassigned","pushTagStart","pushTagStart4","pushTagStart8","pushTagUnassigned","pushBreak","inputLength","parse","input","jumpTable","readUInt16","readUInt32","INT_P","octet","UINT_P_8","UINT_P_16","UINT_P_32","UINT_P_64","INT_N","UINT_N_8","UINT_N_16","UINT_N_32","UINT_N_64","step","BYTE_STRING_8","BYTE_STRING_16","BYTE_STRING_32","BYTE_STRING_64","BYTE_STRING_BREAK","UTF8_STRING_8","UTF8_STRING_16","UTF8_STRING_32","UTF8_STRING_64","UTF8_STRING_BREAK","ARRAY_8","ARRAY_16","ARRAY_32","ARRAY_64","ARRAY_BREAK","MAP_8","MAP_16","MAP_32","MAP_64","MAP_BREAK","TAG_KNOWN","TAG_BIGNUM_POS","TAG_BIGNUM_NEG","TAG_FRAC","TAG_BIGNUM_FLOAT","TAG_UNASSIGNED","TAG_BASE64_URL","TAG_BASE64","TAG_BASE16","TAG_MORE_1","TAG_MORE_2","TAG_MORE_4","TAG_MORE_8","SIMPLE_UNASSIGNED","SIMPLE_FALSE","SIMPLE_TRUE","SIMPLE_NULL","SIMPLE_UNDEFINED","SIMPLE_BYTE","SIMPLE_FLOAT_HALF","f","g","mant","SIMPLE_FLOAT_SINGLE","SIMPLE_FLOAT_DOUBLE","ERROR","parser","utils","Simple","Tagged","URL","Decoder","opts","nextPowerOf2","_heap","_heap8","_buffer","_reset","_knownTags","assign","Date","arrayBufferToBignumber","tags","log","bind","_parents","_depth","_currentParent","ref","_closeParent","_push","createTag","createByteString","createUtf8String","values","createMap","createObject","createArray","_dec","hasChildren","_ref","tmpKey","buildMap","_createParent","_res","tagNumber","typ","raw","createByteStringFromHeap","createInt","createInt32","buildInt32","createInt64","f1","f2","buildInt64","createFloat","createFloatSingle","createFloatDouble","h","createInt32Neg","createInt64Neg","createTrue","createFalse","createNull","createUndefined","createInfinity","createInfinityNeg","createNaN","createNaNNeg","createUtf8StringFromHeap","createSimpleUnassigned","_createArrayStartFixed","len1","len3","len4","_createObjectStartFixed","tag","_decode","decodeFirst","decodeAll","enc","decode","Diagnose","super","fl","isNegativeZero","map","keys","reduce","collectObject","acc","key","constants","HALF","FLOAT","DOUBLE","MAXINT_BN","BUF_NAN","BUF_INF_NEG","BUF_INF_POS","Encoder","options","streaming","stream","onData","semanticTypes","_pushUrl","_pushBigNumber","addTypes","genTypes","addSemanticType","fun","old","result","resultMethod","resultLength","finalize","pushWrite","_pushUInt8","_pushUInt16BE","_pushUInt32BE","_pushDoubleBE","_pushNaN","_pushInfinity","_pushFloat","b2","writeHalf","parseHalf","b4","_pushInt","mt","orig","_pushIntNum","_pushNumber","_pushString","_pushBoolean","_pushUndefined","_pushArray","gen","pushAny","_pushTag","_pushDate","_pushBuffer","_pushNoFilter","_pushRegexp","source","_pushSet","_pushBigint","dec","slide","_pushMap","_pushRawMap","_pushObject","encodeCBOR","keyLength","encode","sort","keySorter","toType","index","o","diagnose","hasParent","err","JSON","stringify","convert","converters","er","Map","u32","u","s16","lenA","lenB","count","_bytesRead","_bytesWrote","wrtBigUInt64LE","checkIntBI","BigInt","wrtBigUInt64BE","readBigUInt64LE","defineBigIntMethod","validateNumber","first","last","boundsError","readBigUInt64BE","readBigInt64LE","readBigInt64BE","writeBigUInt64LE","writeBigUInt64BE","writeBigInt64LE","writeBigInt64BE","errors","E","sym","getMessage","Base","writable","configurable","stack","message","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","ERR_BUFFER_OUT_OF_BOUNDS","msg","received","fn","BufferBigIntNotDefined","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","rt","LN2","URLWithLegacySupport","URLSearchParams","defaultBase","relative","url","location","protocolMap","defaultProtocol","urlParsed","protocol","host","self","path","pathname","auth","username","password","query","startsWith","hash","hostname","href","origin","port","searchParams","createObjectURL","revokeObjectURL","userPass","WINDOW","window","root","JS_SHA256_NO_WINDOW","WEB_WORKER","NODE_JS","JS_SHA256_NO_NODE_JS","process","versions","node","COMMON_JS","JS_SHA256_NO_COMMON_JS","AMD","ARRAY_BUFFER","JS_SHA256_NO_ARRAY_BUFFER","HEX_CHARS","EXTRA","SHIFT","K","OUTPUT_TYPES","blocks","JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW","createOutputMethod","outputType","is224","Sha256","update","createMethod","nodeWrap","create","eval","algorithm","nodeMethod","createHash","digest","createHmacOutputMethod","HmacSha256","createHmacMethod","sharedMemory","h0","h1","h2","h3","h4","h5","h6","h7","block","hBytes","finalized","hashed","oKeyPad","iKeyPad","inner","notString","lastByteIndex","s0","s1","maj","t1","ab","da","cd","bc","hex","arrayBuffer","dataView","DataView","setUint32","innerHash","sha256","sha224","hmac","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","nextTick","title","browser","env","argv","version","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","copyProps","SafeBuffer","__importStar","__esModule","__export","cbor","BufferClasses","Uint16Array","Int8Array","Int16Array","Int32Array","Float32Array","Float64Array","JsonDefaultCborEncoder","_serializer","_stable","priority","match","undefined_","bool","number","doubleFloat","null_","serializeValue","find","getOwnPropertyNames","item","entries","ToCborEncoder","toCBOR","CborSerializer","_encoders","Set","stable","addEncoder","removeEncoder","encoder","delete","add","getEncoderFor","chosenEncoder","serialize","SelfDescribeCborSerializer","_concat","newBuffer","_serializeValue","major","minor","padStart","byte","_serializeNumber","_serializeString","utf8","charcode","uSmall","u8","radix","u16","u64","iSmall","i8","i32","i64","done","newI64","reduceRight","true_","false_","tagged","items","keyA","keyB","localeCompare","singleFloat","single","__webpack_module_cache__","__webpack_require__","moduleId","__webpack_modules__","amdO","getter","definition","globalThis","Function","prop","toStringTag","ReplicaRejectCode","lookupTable","lookUpTable","_isPrincipal","publicKey","sha","shaObj","other","fromText","_a","text","skip","decodeChar","char","principal","toText","isAnonymous","toUint8Array","toHex","checksumArrayBuf","crc","getCrc32","checksum","matches","bits","safeRead","pipe","lebDecode","weight","slebEncode","getLowerBytes","slebDecode","pipeView","blobFromText","blobFromHex","idlLabelToId","label","isSafeInteger","TextEncoder","idlHash","magicNumber","zipWith","xs","ys","TypeTable","_typs","_idx","has","idx","merge","knot","knotIdx","typeName","Visitor","visitType","visitPrimitive","visitEmpty","visitBool","visitNull","visitReserved","visitText","visitNumber","visitInt","visitNat","visitFloat","visitFixedInt","visitFixedNat","visitPrincipal","visitConstruct","visitVec","ty","visitOpt","visitRecord","fields","visitTuple","components","visitVariant","visitRec","visitFunc","visitService","Type","display","valueToString","buildTypeTable","typeTable","_buildTypeTableImpl","PrimitiveType","checkType","ConstructType","RecClass","getType","encodeType","EmptyClass","accept","covariant","encodeValue","decodeValue","BoolClass","NullClass","ReservedClass","isValidUTF8","TextClass","IntClass","NatClass","FloatClass","_bits","FixedIntClass","log2","FixedNatClass","VecClass","_type","_blobOptimization","every","opCode","vec","rets","OptClass","opt","RecordClass","_fields","tryAsTuple","bufs","T","forEach","_","record","expectKey","expectType","TupleClass","_components","tuple","wireType","VariantClass","variant","wireHash","_id","_counter","decodePrincipalId","PrincipalClass","FuncClass","argTypes","retTypes","annotations","types","canister","methodLen","argLen","retLen","annLen","anns","encodeAnnotation","ann","ServiceClass","func","meths","labelBuf","labelLen","magic","typs","vals","toReadableString","rawTable","rawTypes","prevHash","objectLength","funcLength","servLength","rawList","readTypeTable","Rec","Null","Bool","Nat","Int","Nat8","Nat16","Nat32","Nat64","Int8","Int16","Int32","Int64","Float32","Float64","Text","Reserved","Empty","entry","Vec","Opt","Record","Tuple","Variant","Func","Service","buildType","ind","requestId","hashValue","hashString","toHash","encoded","bs","AnonymousIdentity","getPrincipal","request","body","content","serializer","CborTag","decodePositiveBigInt","Semantic","NANOSECONDS_PER_MILLISECONDS","REPLICA_PERMITTED_DRIFT_MILLISECONDS","Expiry","deltaInMSec","_value","now","SubmitRequestType","RequestStatusResponseStatus","DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS","HttpAgent","_pipeline","_rootKeyFetched","rootKey","_identity","_fetch","_host","_credentials","fetch","getDefaultFetch","credentials","Promise","resolve","identity","addTransform","findIndex","canisterId","ecid","effectiveCanisterId","sender","submit","request_type","Call","canister_id","method_name","methodName","ingress_expiry","transformedRequest","_transform","headers","Authorization","btoa","endpoint","transformRequest","response","all","filter","k1","k2","ok","status","statusText","paths","root_key","then","r2","ProxyMessageKind","getDefaultAgent","agent","ic","IDL","Principal","wasm_module","CanisterSettings","compute_allocation","memory_allocation","provisional_create_canister_with_cycles","amount","settings","create_canister","install_code","mode","install","reinstall","upgrade","set_controller","new_controller","getManagementCanister","transform","callConfig","callTransform","queryTransform","AgentError","wasm","wasmBytesBase64","wasmBytes","cachegetUint8Memory0","passArray8ToWasm0","malloc","ptr","memory","async","init","instance","imports","Response","WebAssembly","instantiate","Instance","load","__wbindgen_wasm_module","verify","blsVerify","pk","sig","bls_init","pk1","sig1","msg1","w","ptr0","len0","__wbindgen_malloc","ptr1","ptr2","bls_verify","UnverifiedCertificateError","isBufferEqual","Certificate","_agent","verified","_rootKey","cert","certificate","lookupEx","checkState","tree","maybeReturn","lookup_path","blob","lookupPathEx","rootHash","reconstruct","derKey","_checkDelegation","delegation","signature","expectedLength","DER_PREFIX","extractDER","domain_sep","subnet_id","trees","find_label","flatten_forks","pollForResponse","strategy","state","readState","maybeBuf","Unknown","Replied","Received","Processing","Rejected","rejectCode","rejectMessage","Done","ActorCallError","props","QueryCallRejectedError","Status","Code","reject_code","Message","reject_message","UpdateCallRejectedError","CanisterInstallMode","metadataSymbol","for","metadata","freeze","actor","service","Install","wasmModule","interfaceFactory","createCanister","createActor","DEFAULT_ACTOR_CONFIG","_createActorMethod","configuration","createActorClass","decodeReturnValue","returnValues","pollingStrategyFactory","strategies","chain","condition","timeInMsec","startingThrottleInMsec","backoffFactor","currentThrottling","backoff","caller","_b","cid","reply","pollStrategy","responseBytes","handler","withOptions","idlFactory","ic_demo","document","getElementById","addEventListener","greeting","greet","innerText"],"mappings":"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SAASyR,GAAOxD,GACdA,EAAQA,EAAQ,EAEhB,OAAO,EAGT,SAASrD,GAAOqD,GACdA,EAAQA,EAAQ,EAEhBR,IAEAzN,EAAUA,EAAS,EAAK,EAExB,OAAO,EAKT,IAAI6N,GAAY,CAEdG,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EAEAE,EAEAC,EAEAC,EAEAC,EACAoD,GACAA,GACAA,GACAA,GAEAnD,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EAEAC,EAEAC,EAEAC,GAEAC,GACA+C,GACAA,GACAA,GACAA,GAEA/I,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GAEAkG,GAEAC,GAEAC,GAEAC,GACA0C,GACAA,GACAA,GAEAzC,GAEArG,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GAEAsG,GAEAC,GAEAC,GAEAC,GAEAqC,GACAA,GACAA,GACApC,GAEAzG,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GAEA0G,GAEAC,GAEAC,GAEAC,GAEAgC,GACAA,GACAA,GACA/B,GAEA7G,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACA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","file":"index.js","sourcesContent":["/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n(function(){\n  \"use strict\";\n\n  var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n  // Use a lookup table to find the index.\n  var lookup = new Uint8Array(256);\n  for (var i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n  }\n\n  exports.encode = function(arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer),\n    i, len = bytes.length, base64 = \"\";\n\n    for (i = 0; i < len; i+=3) {\n      base64 += chars[bytes[i] >> 2];\n      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n      base64 += chars[bytes[i + 2] & 63];\n    }\n\n    if ((len % 3) === 2) {\n      base64 = base64.substring(0, base64.length - 1) + \"=\";\n    } else if (len % 3 === 1) {\n      base64 = base64.substring(0, base64.length - 2) + \"==\";\n    }\n\n    return base64;\n  };\n\n  exports.decode =  function(base64) {\n    var bufferLength = base64.length * 0.75,\n    len = base64.length, i, p = 0,\n    encoded1, encoded2, encoded3, encoded4;\n\n    if (base64[base64.length - 1] === \"=\") {\n      bufferLength--;\n      if (base64[base64.length - 2] === \"=\") {\n        bufferLength--;\n      }\n    }\n\n    var arraybuffer = new ArrayBuffer(bufferLength),\n    bytes = new Uint8Array(arraybuffer);\n\n    for (i = 0; i < len; i+=4) {\n      encoded1 = lookup[base64.charCodeAt(i)];\n      encoded2 = lookup[base64.charCodeAt(i+1)];\n      encoded3 = lookup[base64.charCodeAt(i+2)];\n      encoded4 = lookup[base64.charCodeAt(i+3)];\n\n      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n\n    return arraybuffer;\n  };\n})();\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v9.0.1\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2020 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *      MIT Licensed.\r\n *\r\n *      BigNumber.prototype methods     |  BigNumber methods\r\n *                                      |\r\n *      absoluteValue            abs    |  clone\r\n *      comparedTo                      |  config               set\r\n *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n *      dividedBy                div    |      ROUNDING_MODE\r\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n *      exponentiatedBy          pow    |      RANGE\r\n *      integerValue                    |      CRYPTO\r\n *      isEqualTo                eq     |      MODULO_MODE\r\n *      isFinite                        |      POW_PRECISION\r\n *      isGreaterThan            gt     |      FORMAT\r\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n *      isInteger                       |  isBigNumber\r\n *      isLessThan               lt     |  maximum              max\r\n *      isLessThanOrEqualTo      lte    |  minimum              min\r\n *      isNaN                           |  random\r\n *      isNegative                      |  sum\r\n *      isPositive                      |\r\n *      isZero                          |\r\n *      minus                           |\r\n *      modulo                   mod    |\r\n *      multipliedBy             times  |\r\n *      negated                         |\r\n *      plus                            |\r\n *      precision                sd     |\r\n *      shiftedBy                       |\r\n *      squareRoot               sqrt   |\r\n *      toExponential                   |\r\n *      toFixed                         |\r\n *      toFormat                        |\r\n *      toFraction                      |\r\n *      toJSON                          |\r\n *      toNumber                        |\r\n *      toPrecision                     |\r\n *      toString                        |\r\n *      valueOf                         |\r\n *\r\n */\r\n\r\n\r\n  var BigNumber,\r\n    isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n    mathceil = Math.ceil,\r\n    mathfloor = Math.floor,\r\n\r\n    bignumberError = '[BigNumber Error] ',\r\n    tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n    BASE = 1e14,\r\n    LOG_BASE = 14,\r\n    MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n    // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n    POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n    SQRT_BASE = 1e7,\r\n\r\n    // EDITABLE\r\n    // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n    // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n    MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n  /*\r\n   * Create and return a BigNumber constructor.\r\n   */\r\n  function clone(configObject) {\r\n    var div, convertBase, parseNumeric,\r\n      P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n      ONE = new BigNumber(1),\r\n\r\n\r\n      //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n      // The default values below must be integers within the inclusive ranges stated.\r\n      // The values can also be changed at run-time using BigNumber.set.\r\n\r\n      // The maximum number of decimal places for operations involving division.\r\n      DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n      // The rounding mode used when rounding to the above decimal places, and when using\r\n      // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n      // UP         0 Away from zero.\r\n      // DOWN       1 Towards zero.\r\n      // CEIL       2 Towards +Infinity.\r\n      // FLOOR      3 Towards -Infinity.\r\n      // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n      // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n      // The exponent value at and beneath which toString returns exponential notation.\r\n      // Number type: -7\r\n      TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n      // The exponent value at and above which toString returns exponential notation.\r\n      // Number type: 21\r\n      TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n      // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n      // The minimum exponent value, beneath which underflow to zero occurs.\r\n      // Number type: -324  (5e-324)\r\n      MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n      // The maximum exponent value, above which overflow to Infinity occurs.\r\n      // Number type:  308  (1.7976931348623157e+308)\r\n      // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n      MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n      // Whether to use cryptographically-secure random number generation, if available.\r\n      CRYPTO = false,                          // true or false\r\n\r\n      // The modulo mode used when calculating the modulus: a mod n.\r\n      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n      // The remainder (r) is calculated as: r = a - n * q.\r\n      //\r\n      // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n      // DOWN      1 The remainder has the same sign as the dividend.\r\n      //             This modulo mode is commonly known as 'truncated division' and is\r\n      //             equivalent to (a % n) in JavaScript.\r\n      // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n      // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n      // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n      //             The remainder is always positive.\r\n      //\r\n      // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n      // modes are commonly used for the modulus operation.\r\n      // Although the other rounding modes can also be used, they may not give useful results.\r\n      MODULO_MODE = 1,                         // 0 to 9\r\n\r\n      // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n      // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n      POW_PRECISION = 0,                    // 0 to MAX\r\n\r\n      // The format specification used by the BigNumber.prototype.toFormat method.\r\n      FORMAT = {\r\n        prefix: '',\r\n        groupSize: 3,\r\n        secondaryGroupSize: 0,\r\n        groupSeparator: ',',\r\n        decimalSeparator: '.',\r\n        fractionGroupSize: 0,\r\n        fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n        suffix: ''\r\n      },\r\n\r\n      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n      // '-', '.', whitespace, or repeated character.\r\n      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';\r\n\r\n\r\n    //------------------------------------------------------------------------------------------\r\n\r\n\r\n    // CONSTRUCTOR\r\n\r\n\r\n    /*\r\n     * The BigNumber constructor and exported function.\r\n     * Create and return a new instance of a BigNumber object.\r\n     *\r\n     * v {number|string|BigNumber} A numeric value.\r\n     * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n     */\r\n    function BigNumber(v, b) {\r\n      var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n        x = this;\r\n\r\n      // Enable constructor call without `new`.\r\n      if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n      if (b == null) {\r\n\r\n        if (v && v._isBigNumber === true) {\r\n          x.s = v.s;\r\n\r\n          if (!v.c || v.e > MAX_EXP) {\r\n            x.c = x.e = null;\r\n          } else if (v.e < MIN_EXP) {\r\n            x.c = [x.e = 0];\r\n          } else {\r\n            x.e = v.e;\r\n            x.c = v.c.slice();\r\n          }\r\n\r\n          return;\r\n        }\r\n\r\n        if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n          // Use `1 / n` to handle minus zero also.\r\n          x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n          // Fast path for integers, where n < 2147483648 (2**31).\r\n          if (v === ~~v) {\r\n            for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n            if (e > MAX_EXP) {\r\n              x.c = x.e = null;\r\n            } else {\r\n              x.e = e;\r\n              x.c = [v];\r\n            }\r\n\r\n            return;\r\n          }\r\n\r\n          str = String(v);\r\n        } else {\r\n\r\n          if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n          x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n        // Exponential form?\r\n        if ((i = str.search(/e/i)) > 0) {\r\n\r\n          // Determine exponent.\r\n          if (e < 0) e = i;\r\n          e += +str.slice(i + 1);\r\n          str = str.substring(0, i);\r\n        } else if (e < 0) {\r\n\r\n          // Integer.\r\n          e = str.length;\r\n        }\r\n\r\n      } else {\r\n\r\n        // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n        // Allow exponential notation to be used with base 10 argument, while\r\n        // also rounding to DECIMAL_PLACES as with other bases.\r\n        if (b == 10) {\r\n          x = new BigNumber(v);\r\n          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n        }\r\n\r\n        str = String(v);\r\n\r\n        if (isNum = typeof v == 'number') {\r\n\r\n          // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n          if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n          x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n          // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n          if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n            throw Error\r\n             (tooManyDigits + v);\r\n          }\r\n        } else {\r\n          x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        alphabet = ALPHABET.slice(0, b);\r\n        e = i = 0;\r\n\r\n        // Check that str is a valid base b number.\r\n        // Don't use RegExp, so alphabet can contain special characters.\r\n        for (len = str.length; i < len; i++) {\r\n          if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n            if (c == '.') {\r\n\r\n              // If '.' is not the first character and it has not be found before.\r\n              if (i > e) {\r\n                e = len;\r\n                continue;\r\n              }\r\n            } else if (!caseChanged) {\r\n\r\n              // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n              if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                  str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n                caseChanged = true;\r\n                i = -1;\r\n                e = 0;\r\n                continue;\r\n              }\r\n            }\r\n\r\n            return parseNumeric(x, String(v), isNum, b);\r\n          }\r\n        }\r\n\r\n        // Prevent later check for length on converted number.\r\n        isNum = false;\r\n        str = convertBase(str, b, 10, x.s);\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n        else e = str.length;\r\n      }\r\n\r\n      // Determine leading zeros.\r\n      for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n      // Determine trailing zeros.\r\n      for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n      if (str = str.slice(i, ++len)) {\r\n        len -= i;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (isNum && BigNumber.DEBUG &&\r\n          len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n            throw Error\r\n             (tooManyDigits + (x.s * v));\r\n        }\r\n\r\n         // Overflow?\r\n        if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n          // Infinity.\r\n          x.c = x.e = null;\r\n\r\n        // Underflow?\r\n        } else if (e < MIN_EXP) {\r\n\r\n          // Zero.\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = e;\r\n          x.c = [];\r\n\r\n          // Transform base\r\n\r\n          // e is the base 10 exponent.\r\n          // i is where to slice str to get the first element of the coefficient array.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n          if (i < len) {\r\n            if (i) x.c.push(+str.slice(0, i));\r\n\r\n            for (len -= LOG_BASE; i < len;) {\r\n              x.c.push(+str.slice(i, i += LOG_BASE));\r\n            }\r\n\r\n            i = LOG_BASE - (str = str.slice(i)).length;\r\n          } else {\r\n            i -= len;\r\n          }\r\n\r\n          for (; i--; str += '0');\r\n          x.c.push(+str);\r\n        }\r\n      } else {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n\r\n    // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n    BigNumber.clone = clone;\r\n\r\n    BigNumber.ROUND_UP = 0;\r\n    BigNumber.ROUND_DOWN = 1;\r\n    BigNumber.ROUND_CEIL = 2;\r\n    BigNumber.ROUND_FLOOR = 3;\r\n    BigNumber.ROUND_HALF_UP = 4;\r\n    BigNumber.ROUND_HALF_DOWN = 5;\r\n    BigNumber.ROUND_HALF_EVEN = 6;\r\n    BigNumber.ROUND_HALF_CEIL = 7;\r\n    BigNumber.ROUND_HALF_FLOOR = 8;\r\n    BigNumber.EUCLID = 9;\r\n\r\n\r\n    /*\r\n     * Configure infrequently-changing library-wide settings.\r\n     *\r\n     * Accept an object with the following optional properties (if the value of a property is\r\n     * a number, it must be an integer within the inclusive range stated):\r\n     *\r\n     *   DECIMAL_PLACES   {number}           0 to MAX\r\n     *   ROUNDING_MODE    {number}           0 to 8\r\n     *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n     *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n     *   CRYPTO           {boolean}          true or false\r\n     *   MODULO_MODE      {number}           0 to 9\r\n     *   POW_PRECISION       {number}           0 to MAX\r\n     *   ALPHABET         {string}           A string of two or more unique characters which does\r\n     *                                       not contain '.'.\r\n     *   FORMAT           {object}           An object with some of the following properties:\r\n     *     prefix                 {string}\r\n     *     groupSize              {number}\r\n     *     secondaryGroupSize     {number}\r\n     *     groupSeparator         {string}\r\n     *     decimalSeparator       {string}\r\n     *     fractionGroupSize      {number}\r\n     *     fractionGroupSeparator {string}\r\n     *     suffix                 {string}\r\n     *\r\n     * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n     *\r\n     * E.g.\r\n     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n     *\r\n     * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n     *\r\n     * Return an object with the properties current values.\r\n     */\r\n    BigNumber.config = BigNumber.set = function (obj) {\r\n      var p, v;\r\n\r\n      if (obj != null) {\r\n\r\n        if (typeof obj == 'object') {\r\n\r\n          // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            DECIMAL_PLACES = v;\r\n          }\r\n\r\n          // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n          // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 8, p);\r\n            ROUNDING_MODE = v;\r\n          }\r\n\r\n          // EXPONENTIAL_AT {number|number[]}\r\n          // Integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n          // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, 0, p);\r\n              intCheck(v[1], 0, MAX, p);\r\n              TO_EXP_NEG = v[0];\r\n              TO_EXP_POS = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n            }\r\n          }\r\n\r\n          // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n          // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n          if (obj.hasOwnProperty(p = 'RANGE')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, -1, p);\r\n              intCheck(v[1], 1, MAX, p);\r\n              MIN_EXP = v[0];\r\n              MAX_EXP = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              if (v) {\r\n                MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n              } else {\r\n                throw Error\r\n                 (bignumberError + p + ' cannot be zero: ' + v);\r\n              }\r\n            }\r\n          }\r\n\r\n          // CRYPTO {boolean} true or false.\r\n          // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n          // '[BigNumber Error] crypto unavailable'\r\n          if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n            v = obj[p];\r\n            if (v === !!v) {\r\n              if (v) {\r\n                if (typeof crypto != 'undefined' && crypto &&\r\n                 (crypto.getRandomValues || crypto.randomBytes)) {\r\n                  CRYPTO = v;\r\n                } else {\r\n                  CRYPTO = !v;\r\n                  throw Error\r\n                   (bignumberError + 'crypto unavailable');\r\n                }\r\n              } else {\r\n                CRYPTO = v;\r\n              }\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' not true or false: ' + v);\r\n            }\r\n          }\r\n\r\n          // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n          // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 9, p);\r\n            MODULO_MODE = v;\r\n          }\r\n\r\n          // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            POW_PRECISION = v;\r\n          }\r\n\r\n          // FORMAT {object}\r\n          // '[BigNumber Error] FORMAT not an object: {v}'\r\n          if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n            v = obj[p];\r\n            if (typeof v == 'object') FORMAT = v;\r\n            else throw Error\r\n             (bignumberError + p + ' not an object: ' + v);\r\n          }\r\n\r\n          // ALPHABET {string}\r\n          // '[BigNumber Error] ALPHABET invalid: {v}'\r\n          if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n            v = obj[p];\r\n\r\n            // Disallow if less than two characters,\r\n            // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n            if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n              ALPHABET = v;\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' invalid: ' + v);\r\n            }\r\n          }\r\n\r\n        } else {\r\n\r\n          // '[BigNumber Error] Object expected: {v}'\r\n          throw Error\r\n           (bignumberError + 'Object expected: ' + obj);\r\n        }\r\n      }\r\n\r\n      return {\r\n        DECIMAL_PLACES: DECIMAL_PLACES,\r\n        ROUNDING_MODE: ROUNDING_MODE,\r\n        EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n        RANGE: [MIN_EXP, MAX_EXP],\r\n        CRYPTO: CRYPTO,\r\n        MODULO_MODE: MODULO_MODE,\r\n        POW_PRECISION: POW_PRECISION,\r\n        FORMAT: FORMAT,\r\n        ALPHABET: ALPHABET\r\n      };\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if v is a BigNumber instance, otherwise return false.\r\n     *\r\n     * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n     *\r\n     * v {any}\r\n     *\r\n     * '[BigNumber Error] Invalid BigNumber: {v}'\r\n     */\r\n    BigNumber.isBigNumber = function (v) {\r\n      if (!v || v._isBigNumber !== true) return false;\r\n      if (!BigNumber.DEBUG) return true;\r\n\r\n      var i, n,\r\n        c = v.c,\r\n        e = v.e,\r\n        s = v.s;\r\n\r\n      out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n        if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n          // If the first element is zero, the BigNumber value must be zero.\r\n          if (c[0] === 0) {\r\n            if (e === 0 && c.length === 1) return true;\r\n            break out;\r\n          }\r\n\r\n          // Calculate number of digits that c[0] should have, based on the exponent.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (i < 1) i += LOG_BASE;\r\n\r\n          // Calculate number of digits of c[0].\r\n          //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n          if (String(c[0]).length == i) {\r\n\r\n            for (i = 0; i < c.length; i++) {\r\n              n = c[i];\r\n              if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n            }\r\n\r\n            // Last element cannot be zero, unless it is the only element.\r\n            if (n !== 0) return true;\r\n          }\r\n        }\r\n\r\n      // Infinity/NaN\r\n      } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n        return true;\r\n      }\r\n\r\n      throw Error\r\n        (bignumberError + 'Invalid BigNumber: ' + v);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the maximum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.maximum = BigNumber.max = function () {\r\n      return maxOrMin(arguments, P.lt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the minimum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.minimum = BigNumber.min = function () {\r\n      return maxOrMin(arguments, P.gt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n     * zeros are produced).\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n     * '[BigNumber Error] crypto unavailable'\r\n     */\r\n    BigNumber.random = (function () {\r\n      var pow2_53 = 0x20000000000000;\r\n\r\n      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n      // Check if Math.random() produces more than 32 bits of randomness.\r\n      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n       ? function () { return mathfloor(Math.random() * pow2_53); }\r\n       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n         (Math.random() * 0x800000 | 0); };\r\n\r\n      return function (dp) {\r\n        var a, b, e, k, v,\r\n          i = 0,\r\n          c = [],\r\n          rand = new BigNumber(ONE);\r\n\r\n        if (dp == null) dp = DECIMAL_PLACES;\r\n        else intCheck(dp, 0, MAX);\r\n\r\n        k = mathceil(dp / LOG_BASE);\r\n\r\n        if (CRYPTO) {\r\n\r\n          // Browsers supporting crypto.getRandomValues.\r\n          if (crypto.getRandomValues) {\r\n\r\n            a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n            for (; i < k;) {\r\n\r\n              // 53 bits:\r\n              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n              // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n              //                                     11111 11111111 11111111\r\n              // 0x20000 is 2^21.\r\n              v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n              // Rejection sampling:\r\n              // 0 <= v < 9007199254740992\r\n              // Probability that v >= 9e15, is\r\n              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n              if (v >= 9e15) {\r\n                b = crypto.getRandomValues(new Uint32Array(2));\r\n                a[i] = b[0];\r\n                a[i + 1] = b[1];\r\n              } else {\r\n\r\n                // 0 <= v <= 8999999999999999\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 2;\r\n              }\r\n            }\r\n            i = k / 2;\r\n\r\n          // Node.js supporting crypto.randomBytes.\r\n          } else if (crypto.randomBytes) {\r\n\r\n            // buffer\r\n            a = crypto.randomBytes(k *= 7);\r\n\r\n            for (; i < k;) {\r\n\r\n              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n              // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n              // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n              // 0 <= v < 9007199254740992\r\n              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n              if (v >= 9e15) {\r\n                crypto.randomBytes(7).copy(a, i);\r\n              } else {\r\n\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 7;\r\n              }\r\n            }\r\n            i = k / 7;\r\n          } else {\r\n            CRYPTO = false;\r\n            throw Error\r\n             (bignumberError + 'crypto unavailable');\r\n          }\r\n        }\r\n\r\n        // Use Math.random.\r\n        if (!CRYPTO) {\r\n\r\n          for (; i < k;) {\r\n            v = random53bitInt();\r\n            if (v < 9e15) c[i++] = v % 1e14;\r\n          }\r\n        }\r\n\r\n        k = c[--i];\r\n        dp %= LOG_BASE;\r\n\r\n        // Convert trailing digits to zeros according to dp.\r\n        if (k && dp) {\r\n          v = POWS_TEN[LOG_BASE - dp];\r\n          c[i] = mathfloor(k / v) * v;\r\n        }\r\n\r\n        // Remove trailing elements which are zero.\r\n        for (; c[i] === 0; c.pop(), i--);\r\n\r\n        // Zero?\r\n        if (i < 0) {\r\n          c = [e = 0];\r\n        } else {\r\n\r\n          // Remove leading elements which are zero and adjust exponent accordingly.\r\n          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n          // Count the digits of the first element of c to determine leading zeros, and...\r\n          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n          // adjust the exponent accordingly.\r\n          if (i < LOG_BASE) e -= LOG_BASE - i;\r\n        }\r\n\r\n        rand.e = e;\r\n        rand.c = c;\r\n        return rand;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the sum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.sum = function () {\r\n      var i = 1,\r\n        args = arguments,\r\n        sum = new BigNumber(args[0]);\r\n      for (; i < args.length;) sum = sum.plus(args[i++]);\r\n      return sum;\r\n    };\r\n\r\n\r\n    // PRIVATE FUNCTIONS\r\n\r\n\r\n    // Called by BigNumber and BigNumber.prototype.toString.\r\n    convertBase = (function () {\r\n      var decimal = '0123456789';\r\n\r\n      /*\r\n       * Convert string of baseIn to an array of numbers of baseOut.\r\n       * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n       */\r\n      function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n        var j,\r\n          arr = [0],\r\n          arrL,\r\n          i = 0,\r\n          len = str.length;\r\n\r\n        for (; i < len;) {\r\n          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n          arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n          for (j = 0; j < arr.length; j++) {\r\n\r\n            if (arr[j] > baseOut - 1) {\r\n              if (arr[j + 1] == null) arr[j + 1] = 0;\r\n              arr[j + 1] += arr[j] / baseOut | 0;\r\n              arr[j] %= baseOut;\r\n            }\r\n          }\r\n        }\r\n\r\n        return arr.reverse();\r\n      }\r\n\r\n      // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n      // If the caller is toString, we are converting from base 10 to baseOut.\r\n      // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n      return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n        var alphabet, d, e, k, r, x, xc, y,\r\n          i = str.indexOf('.'),\r\n          dp = DECIMAL_PLACES,\r\n          rm = ROUNDING_MODE;\r\n\r\n        // Non-integer.\r\n        if (i >= 0) {\r\n          k = POW_PRECISION;\r\n\r\n          // Unlimited precision.\r\n          POW_PRECISION = 0;\r\n          str = str.replace('.', '');\r\n          y = new BigNumber(baseIn);\r\n          x = y.pow(str.length - i);\r\n          POW_PRECISION = k;\r\n\r\n          // Convert str as if an integer, then restore the fraction part by dividing the\r\n          // result by its base raised to a power.\r\n\r\n          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n           10, baseOut, decimal);\r\n          y.e = y.c.length;\r\n        }\r\n\r\n        // Convert the number as integer.\r\n\r\n        xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n         ? (alphabet = ALPHABET, decimal)\r\n         : (alphabet = decimal, ALPHABET));\r\n\r\n        // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n        e = k = xc.length;\r\n\r\n        // Remove trailing zeros.\r\n        for (; xc[--k] == 0; xc.pop());\r\n\r\n        // Zero?\r\n        if (!xc[0]) return alphabet.charAt(0);\r\n\r\n        // Does str represent an integer? If so, no need for the division.\r\n        if (i < 0) {\r\n          --e;\r\n        } else {\r\n          x.c = xc;\r\n          x.e = e;\r\n\r\n          // The sign is needed for correct rounding.\r\n          x.s = sign;\r\n          x = div(x, y, dp, rm, baseOut);\r\n          xc = x.c;\r\n          r = x.r;\r\n          e = x.e;\r\n        }\r\n\r\n        // xc now represents str converted to baseOut.\r\n\r\n        // THe index of the rounding digit.\r\n        d = e + dp + 1;\r\n\r\n        // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n        i = xc[d];\r\n\r\n        // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n        k = baseOut / 2;\r\n        r = r || d < 0 || xc[d + 1] != null;\r\n\r\n        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n               rm == (x.s < 0 ? 8 : 7));\r\n\r\n        // If the index of the rounding digit is not greater than zero, or xc represents\r\n        // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n        // such as 0.00001.\r\n        if (d < 1 || !xc[0]) {\r\n\r\n          // 1^-dp or 0\r\n          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n        } else {\r\n\r\n          // Truncate xc to the required number of decimal places.\r\n          xc.length = d;\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            // Rounding up may mean the previous digit has to be rounded up and so on.\r\n            for (--baseOut; ++xc[--d] > baseOut;) {\r\n              xc[d] = 0;\r\n\r\n              if (!d) {\r\n                ++e;\r\n                xc = [1].concat(xc);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Determine trailing zeros.\r\n          for (k = xc.length; !xc[--k];);\r\n\r\n          // E.g. [4, 11, 15] becomes 4bf.\r\n          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n          // Add leading zeros, decimal point and trailing zeros as required.\r\n          str = toFixedPoint(str, e, alphabet.charAt(0));\r\n        }\r\n\r\n        // The caller will add the sign.\r\n        return str;\r\n      };\r\n    })();\r\n\r\n\r\n    // Perform division in the specified base. Called by div and convertBase.\r\n    div = (function () {\r\n\r\n      // Assume non-zero x and k.\r\n      function multiply(x, k, base) {\r\n        var m, temp, xlo, xhi,\r\n          carry = 0,\r\n          i = x.length,\r\n          klo = k % SQRT_BASE,\r\n          khi = k / SQRT_BASE | 0;\r\n\r\n        for (x = x.slice(); i--;) {\r\n          xlo = x[i] % SQRT_BASE;\r\n          xhi = x[i] / SQRT_BASE | 0;\r\n          m = khi * xlo + xhi * klo;\r\n          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n          x[i] = temp % base;\r\n        }\r\n\r\n        if (carry) x = [carry].concat(x);\r\n\r\n        return x;\r\n      }\r\n\r\n      function compare(a, b, aL, bL) {\r\n        var i, cmp;\r\n\r\n        if (aL != bL) {\r\n          cmp = aL > bL ? 1 : -1;\r\n        } else {\r\n\r\n          for (i = cmp = 0; i < aL; i++) {\r\n\r\n            if (a[i] != b[i]) {\r\n              cmp = a[i] > b[i] ? 1 : -1;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n\r\n        return cmp;\r\n      }\r\n\r\n      function subtract(a, b, aL, base) {\r\n        var i = 0;\r\n\r\n        // Subtract b from a.\r\n        for (; aL--;) {\r\n          a[aL] -= i;\r\n          i = a[aL] < b[aL] ? 1 : 0;\r\n          a[aL] = i * base + a[aL] - b[aL];\r\n        }\r\n\r\n        // Remove leading zeros.\r\n        for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n      }\r\n\r\n      // x: dividend, y: divisor.\r\n      return function (x, y, dp, rm, base) {\r\n        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n          yL, yz,\r\n          s = x.s == y.s ? 1 : -1,\r\n          xc = x.c,\r\n          yc = y.c;\r\n\r\n        // Either NaN, Infinity or 0?\r\n        if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n          return new BigNumber(\r\n\r\n           // Return NaN if either NaN, or both Infinity or 0.\r\n           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n            xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n         );\r\n        }\r\n\r\n        q = new BigNumber(s);\r\n        qc = q.c = [];\r\n        e = x.e - y.e;\r\n        s = dp + e + 1;\r\n\r\n        if (!base) {\r\n          base = BASE;\r\n          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n          s = s / LOG_BASE | 0;\r\n        }\r\n\r\n        // Result exponent may be one less then the current value of e.\r\n        // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n        for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n        if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n        if (s < 0) {\r\n          qc.push(1);\r\n          more = true;\r\n        } else {\r\n          xL = xc.length;\r\n          yL = yc.length;\r\n          i = 0;\r\n          s += 2;\r\n\r\n          // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n          n = mathfloor(base / (yc[0] + 1));\r\n\r\n          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n          if (n > 1) {\r\n            yc = multiply(yc, n, base);\r\n            xc = multiply(xc, n, base);\r\n            yL = yc.length;\r\n            xL = xc.length;\r\n          }\r\n\r\n          xi = yL;\r\n          rem = xc.slice(0, yL);\r\n          remL = rem.length;\r\n\r\n          // Add zeros to make remainder as long as divisor.\r\n          for (; remL < yL; rem[remL++] = 0);\r\n          yz = yc.slice();\r\n          yz = [0].concat(yz);\r\n          yc0 = yc[0];\r\n          if (yc[1] >= base / 2) yc0++;\r\n          // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n          do {\r\n            n = 0;\r\n\r\n            // Compare divisor and remainder.\r\n            cmp = compare(yc, rem, yL, remL);\r\n\r\n            // If divisor < remainder.\r\n            if (cmp < 0) {\r\n\r\n              // Calculate trial digit, n.\r\n\r\n              rem0 = rem[0];\r\n              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n              // n is how many times the divisor goes into the current remainder.\r\n              n = mathfloor(rem0 / yc0);\r\n\r\n              //  Algorithm:\r\n              //  product = divisor multiplied by trial digit (n).\r\n              //  Compare product and remainder.\r\n              //  If product is greater than remainder:\r\n              //    Subtract divisor from product, decrement trial digit.\r\n              //  Subtract product from remainder.\r\n              //  If product was less than remainder at the last compare:\r\n              //    Compare new remainder and divisor.\r\n              //    If remainder is greater than divisor:\r\n              //      Subtract divisor from remainder, increment trial digit.\r\n\r\n              if (n > 1) {\r\n\r\n                // n may be > base only when base is 3.\r\n                if (n >= base) n = base - 1;\r\n\r\n                // product = divisor * trial digit.\r\n                prod = multiply(yc, n, base);\r\n                prodL = prod.length;\r\n                remL = rem.length;\r\n\r\n                // Compare product and remainder.\r\n                // If product > remainder then trial digit n too high.\r\n                // n is 1 too high about 5% of the time, and is not known to have\r\n                // ever been more than 1 too high.\r\n                while (compare(prod, rem, prodL, remL) == 1) {\r\n                  n--;\r\n\r\n                  // Subtract divisor from product.\r\n                  subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                  prodL = prod.length;\r\n                  cmp = 1;\r\n                }\r\n              } else {\r\n\r\n                // n is 0 or 1, cmp is -1.\r\n                // If n is 0, there is no need to compare yc and rem again below,\r\n                // so change cmp to 1 to avoid it.\r\n                // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n                if (n == 0) {\r\n\r\n                  // divisor < remainder, so n must be at least 1.\r\n                  cmp = n = 1;\r\n                }\r\n\r\n                // product = divisor\r\n                prod = yc.slice();\r\n                prodL = prod.length;\r\n              }\r\n\r\n              if (prodL < remL) prod = [0].concat(prod);\r\n\r\n              // Subtract product from remainder.\r\n              subtract(rem, prod, remL, base);\r\n              remL = rem.length;\r\n\r\n               // If product was < remainder.\r\n              if (cmp == -1) {\r\n\r\n                // Compare divisor and new remainder.\r\n                // If divisor < new remainder, subtract divisor from remainder.\r\n                // Trial digit n too low.\r\n                // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n                while (compare(yc, rem, yL, remL) < 1) {\r\n                  n++;\r\n\r\n                  // Subtract divisor from remainder.\r\n                  subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                  remL = rem.length;\r\n                }\r\n              }\r\n            } else if (cmp === 0) {\r\n              n++;\r\n              rem = [0];\r\n            } // else cmp === 1 and n will be 0\r\n\r\n            // Add the next digit, n, to the result array.\r\n            qc[i++] = n;\r\n\r\n            // Update the remainder.\r\n            if (rem[0]) {\r\n              rem[remL++] = xc[xi] || 0;\r\n            } else {\r\n              rem = [xc[xi]];\r\n              remL = 1;\r\n            }\r\n          } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n          more = rem[0] != null;\r\n\r\n          // Leading zero?\r\n          if (!qc[0]) qc.splice(0, 1);\r\n        }\r\n\r\n        if (base == BASE) {\r\n\r\n          // To calculate q.e, first get the number of digits of qc[0].\r\n          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n        // Caller is convertBase.\r\n        } else {\r\n          q.e = e;\r\n          q.r = +more;\r\n        }\r\n\r\n        return q;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n     * notation rounded to the specified decimal places or significant digits.\r\n     *\r\n     * n: a BigNumber.\r\n     * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n     * rm: the rounding mode.\r\n     * id: 1 (toExponential) or 2 (toPrecision).\r\n     */\r\n    function format(n, i, rm, id) {\r\n      var c0, e, ne, len, str;\r\n\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      if (!n.c) return n.toString();\r\n\r\n      c0 = n.c[0];\r\n      ne = n.e;\r\n\r\n      if (i == null) {\r\n        str = coeffToString(n.c);\r\n        str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n         ? toExponential(str, ne)\r\n         : toFixedPoint(str, ne, '0');\r\n      } else {\r\n        n = round(new BigNumber(n), i, rm);\r\n\r\n        // n.e may have changed if the value was rounded up.\r\n        e = n.e;\r\n\r\n        str = coeffToString(n.c);\r\n        len = str.length;\r\n\r\n        // toPrecision returns exponential notation if the number of significant digits\r\n        // specified is less than the number of digits necessary to represent the integer\r\n        // part of the value in fixed-point notation.\r\n\r\n        // Exponential notation.\r\n        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n          // Append zeros?\r\n          for (; len < i; str += '0', len++);\r\n          str = toExponential(str, e);\r\n\r\n        // Fixed-point notation.\r\n        } else {\r\n          i -= ne;\r\n          str = toFixedPoint(str, e, '0');\r\n\r\n          // Append zeros?\r\n          if (e + 1 > len) {\r\n            if (--i > 0) for (str += '.'; i--; str += '0');\r\n          } else {\r\n            i += e - len;\r\n            if (i > 0) {\r\n              if (e + 1 == len) str += '.';\r\n              for (; i--; str += '0');\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return n.s < 0 && c0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // Handle BigNumber.max and BigNumber.min.\r\n    function maxOrMin(args, method) {\r\n      var n,\r\n        i = 1,\r\n        m = new BigNumber(args[0]);\r\n\r\n      for (; i < args.length; i++) {\r\n        n = new BigNumber(args[i]);\r\n\r\n        // If any number is NaN, return NaN.\r\n        if (!n.s) {\r\n          m = n;\r\n          break;\r\n        } else if (method.call(m, n)) {\r\n          m = n;\r\n        }\r\n      }\r\n\r\n      return m;\r\n    }\r\n\r\n\r\n    /*\r\n     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n     * Called by minus, plus and times.\r\n     */\r\n    function normalise(n, c, e) {\r\n      var i = 1,\r\n        j = c.length;\r\n\r\n       // Remove trailing zeros.\r\n      for (; !c[--j]; c.pop());\r\n\r\n      // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n      for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n      // Overflow?\r\n      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        n.c = n.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        n.c = [n.e = 0];\r\n      } else {\r\n        n.e = e;\r\n        n.c = c;\r\n      }\r\n\r\n      return n;\r\n    }\r\n\r\n\r\n    // Handle values that fail the validity test in BigNumber.\r\n    parseNumeric = (function () {\r\n      var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n        dotAfter = /^([^.]+)\\.$/,\r\n        dotBefore = /^\\.([^.]+)$/,\r\n        isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n        whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n      return function (x, str, isNum, b) {\r\n        var base,\r\n          s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n        // No exception on ±Infinity or NaN.\r\n        if (isInfinityOrNaN.test(s)) {\r\n          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n        } else {\r\n          if (!isNum) {\r\n\r\n            // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n            s = s.replace(basePrefix, function (m, p1, p2) {\r\n              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n              return !b || b == base ? p1 : m;\r\n            });\r\n\r\n            if (b) {\r\n              base = b;\r\n\r\n              // E.g. '1.' to '1', '.1' to '0.1'\r\n              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n            }\r\n\r\n            if (str != s) return new BigNumber(s, base);\r\n          }\r\n\r\n          // '[BigNumber Error] Not a number: {n}'\r\n          // '[BigNumber Error] Not a base {b} number: {n}'\r\n          if (BigNumber.DEBUG) {\r\n            throw Error\r\n              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n          }\r\n\r\n          // NaN\r\n          x.s = null;\r\n        }\r\n\r\n        x.c = x.e = null;\r\n      }\r\n    })();\r\n\r\n\r\n    /*\r\n     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n     * If r is truthy, it is known that there are more digits after the rounding digit.\r\n     */\r\n    function round(x, sd, rm, r) {\r\n      var d, i, j, k, n, ni, rd,\r\n        xc = x.c,\r\n        pows10 = POWS_TEN;\r\n\r\n      // if x is not Infinity or NaN...\r\n      if (xc) {\r\n\r\n        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n        // ni is the index of n within x.c.\r\n        // d is the number of digits of n.\r\n        // i is the index of rd within n including leading zeros.\r\n        // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n        out: {\r\n\r\n          // Get the number of digits of the first element of xc.\r\n          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n          i = sd - d;\r\n\r\n          // If the rounding digit is in the first element of xc...\r\n          if (i < 0) {\r\n            i += LOG_BASE;\r\n            j = sd;\r\n            n = xc[ni = 0];\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = n / pows10[d - j - 1] % 10 | 0;\r\n          } else {\r\n            ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n            if (ni >= xc.length) {\r\n\r\n              if (r) {\r\n\r\n                // Needed by sqrt.\r\n                for (; xc.length <= ni; xc.push(0));\r\n                n = rd = 0;\r\n                d = 1;\r\n                i %= LOG_BASE;\r\n                j = i - LOG_BASE + 1;\r\n              } else {\r\n                break out;\r\n              }\r\n            } else {\r\n              n = k = xc[ni];\r\n\r\n              // Get the number of digits of n.\r\n              for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n              // Get the index of rd within n.\r\n              i %= LOG_BASE;\r\n\r\n              // Get the index of rd within n, adjusted for leading zeros.\r\n              // The number of leading zeros of n is given by LOG_BASE - d.\r\n              j = i - LOG_BASE + d;\r\n\r\n              // Get the rounding digit at index j of n.\r\n              rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\r\n            }\r\n          }\r\n\r\n          r = r || sd < 0 ||\r\n\r\n          // Are there any non-zero digits after the rounding digit?\r\n          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n          r = rm < 4\r\n           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n           : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n            // Check whether the digit to the left of the rounding digit is odd.\r\n            ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n          if (sd < 1 || !xc[0]) {\r\n            xc.length = 0;\r\n\r\n            if (r) {\r\n\r\n              // Convert sd to decimal places.\r\n              sd -= x.e + 1;\r\n\r\n              // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n              x.e = -sd || 0;\r\n            } else {\r\n\r\n              // Zero.\r\n              xc[0] = x.e = 0;\r\n            }\r\n\r\n            return x;\r\n          }\r\n\r\n          // Remove excess digits.\r\n          if (i == 0) {\r\n            xc.length = ni;\r\n            k = 1;\r\n            ni--;\r\n          } else {\r\n            xc.length = ni + 1;\r\n            k = pows10[LOG_BASE - i];\r\n\r\n            // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n            // j > 0 means i > number of leading zeros of n.\r\n            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n          }\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            for (; ;) {\r\n\r\n              // If the digit to be rounded up is in the first element of xc...\r\n              if (ni == 0) {\r\n\r\n                // i will be the length of xc[0] before k is added.\r\n                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n                j = xc[0] += k;\r\n                for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n                // if i != k the length has increased.\r\n                if (i != k) {\r\n                  x.e++;\r\n                  if (xc[0] == BASE) xc[0] = 1;\r\n                }\r\n\r\n                break;\r\n              } else {\r\n                xc[ni] += k;\r\n                if (xc[ni] != BASE) break;\r\n                xc[ni--] = 0;\r\n                k = 1;\r\n              }\r\n            }\r\n          }\r\n\r\n          // Remove trailing zeros.\r\n          for (i = xc.length; xc[--i] === 0; xc.pop());\r\n        }\r\n\r\n        // Overflow? Infinity.\r\n        if (x.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n\r\n        // Underflow? Zero.\r\n        } else if (x.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    function valueOf(n) {\r\n      var str,\r\n        e = n.e;\r\n\r\n      if (e === null) return n.toString();\r\n\r\n      str = coeffToString(n.c);\r\n\r\n      str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n        ? toExponential(str, e)\r\n        : toFixedPoint(str, e, '0');\r\n\r\n      return n.s < 0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n     */\r\n    P.absoluteValue = P.abs = function () {\r\n      var x = new BigNumber(this);\r\n      if (x.s < 0) x.s = 1;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return\r\n     *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     *   0 if they have the same value,\r\n     *   or null if the value of either is NaN.\r\n     */\r\n    P.comparedTo = function (y, b) {\r\n      return compare(this, new BigNumber(y, b));\r\n    };\r\n\r\n\r\n    /*\r\n     * If dp is undefined or null or true or false, return the number of decimal places of the\r\n     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     *\r\n     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.decimalPlaces = P.dp = function (dp, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), dp + x.e + 1, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last number.\r\n      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n      if (n < 0) n = 0;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n / 0 = I\r\n     *  n / N = N\r\n     *  n / I = 0\r\n     *  0 / n = 0\r\n     *  0 / 0 = N\r\n     *  0 / N = N\r\n     *  0 / I = 0\r\n     *  N / n = N\r\n     *  N / 0 = N\r\n     *  N / N = N\r\n     *  N / I = N\r\n     *  I / n = I\r\n     *  I / 0 = I\r\n     *  I / N = N\r\n     *  I / I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.dividedBy = P.div = function (y, b) {\r\n      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n     * BigNumber by the value of BigNumber(y, b).\r\n     */\r\n    P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n      return div(this, new BigNumber(y, b), 0, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n     *\r\n     * If m is present, return the result modulo m.\r\n     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n     *\r\n     * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n     *\r\n     * n {number|string|BigNumber} The exponent. An integer.\r\n     * [m] {number|string|BigNumber} The modulus.\r\n     *\r\n     * '[BigNumber Error] Exponent not an integer: {n}'\r\n     */\r\n    P.exponentiatedBy = P.pow = function (n, m) {\r\n      var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n        x = this;\r\n\r\n      n = new BigNumber(n);\r\n\r\n      // Allow NaN and ±Infinity, but not other non-integers.\r\n      if (n.c && !n.isInteger()) {\r\n        throw Error\r\n          (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n      }\r\n\r\n      if (m != null) m = new BigNumber(m);\r\n\r\n      // Exponent of MAX_SAFE_INTEGER is 15.\r\n      nIsBig = n.e > 14;\r\n\r\n      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n      if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n        // The sign of the result of pow when x is negative depends on the evenness of n.\r\n        // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(n)));\r\n        return m ? y.mod(m) : y;\r\n      }\r\n\r\n      nIsNeg = n.s < 0;\r\n\r\n      if (m) {\r\n\r\n        // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n        isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n        if (isModExp) x = x.mod(m);\r\n\r\n      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n        // [1, 240000000]\r\n        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n        // [80000000000000]  [99999750000000]\r\n        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n        // If x is negative and n is odd, k = -0, else k = 0.\r\n        k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n        // If x >= 1, k = ±Infinity.\r\n        if (x.e > -1) k = 1 / k;\r\n\r\n        // If n is negative return ±0, else return ±Infinity.\r\n        return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n      } else if (POW_PRECISION) {\r\n\r\n        // Truncating each coefficient array to a length of k after each multiplication\r\n        // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n        // i.e. there will be a minimum of 28 guard digits retained.\r\n        k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n      }\r\n\r\n      if (nIsBig) {\r\n        half = new BigNumber(0.5);\r\n        if (nIsNeg) n.s = 1;\r\n        nIsOdd = isOdd(n);\r\n      } else {\r\n        i = Math.abs(+valueOf(n));\r\n        nIsOdd = i % 2;\r\n      }\r\n\r\n      y = new BigNumber(ONE);\r\n\r\n      // Performs 54 loop iterations for n of 9007199254740991.\r\n      for (; ;) {\r\n\r\n        if (nIsOdd) {\r\n          y = y.times(x);\r\n          if (!y.c) break;\r\n\r\n          if (k) {\r\n            if (y.c.length > k) y.c.length = k;\r\n          } else if (isModExp) {\r\n            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n          }\r\n        }\r\n\r\n        if (i) {\r\n          i = mathfloor(i / 2);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        } else {\r\n          n = n.times(half);\r\n          round(n, n.e + 1, 1);\r\n\r\n          if (n.e > 14) {\r\n            nIsOdd = isOdd(n);\r\n          } else {\r\n            i = +valueOf(n);\r\n            if (i === 0) break;\r\n            nIsOdd = i % 2;\r\n          }\r\n        }\r\n\r\n        x = x.times(x);\r\n\r\n        if (k) {\r\n          if (x.c && x.c.length > k) x.c.length = k;\r\n        } else if (isModExp) {\r\n          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (isModExp) return y;\r\n      if (nIsNeg) y = ONE.div(y);\r\n\r\n      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n     */\r\n    P.integerValue = function (rm) {\r\n      var n = new BigNumber(this);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n      return round(n, n.e + 1, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isEqualTo = P.eq = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n     */\r\n    P.isFinite = function () {\r\n      return !!this.c;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isGreaterThan = P.gt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n     */\r\n    P.isInteger = function () {\r\n      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isLessThan = P.lt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n     */\r\n    P.isNaN = function () {\r\n      return !this.s;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is negative, otherwise return false.\r\n     */\r\n    P.isNegative = function () {\r\n      return this.s < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is positive, otherwise return false.\r\n     */\r\n    P.isPositive = function () {\r\n      return this.s > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n     */\r\n    P.isZero = function () {\r\n      return !!this.c && this.c[0] == 0;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n - 0 = n\r\n     *  n - N = N\r\n     *  n - I = -I\r\n     *  0 - n = -n\r\n     *  0 - 0 = 0\r\n     *  0 - N = N\r\n     *  0 - I = -I\r\n     *  N - n = N\r\n     *  N - 0 = N\r\n     *  N - N = N\r\n     *  N - I = N\r\n     *  I - n = I\r\n     *  I - 0 = I\r\n     *  I - N = N\r\n     *  I - I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.minus = function (y, b) {\r\n      var i, j, t, xLTy,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n      if (a != b) {\r\n        y.s = -b;\r\n        return x.plus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Either Infinity?\r\n        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n        // Either zero?\r\n        if (!xc[0] || !yc[0]) {\r\n\r\n          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n           ROUNDING_MODE == 3 ? -0 : 0);\r\n        }\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Determine which is the bigger number.\r\n      if (a = xe - ye) {\r\n\r\n        if (xLTy = a < 0) {\r\n          a = -a;\r\n          t = xc;\r\n        } else {\r\n          ye = xe;\r\n          t = yc;\r\n        }\r\n\r\n        t.reverse();\r\n\r\n        // Prepend zeros to equalise exponents.\r\n        for (b = a; b--; t.push(0));\r\n        t.reverse();\r\n      } else {\r\n\r\n        // Exponents equal. Check digit by digit.\r\n        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n        for (a = b = 0; b < j; b++) {\r\n\r\n          if (xc[b] != yc[b]) {\r\n            xLTy = xc[b] < yc[b];\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // x < y? Point xc to the array of the bigger number.\r\n      if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\r\n\r\n      b = (j = yc.length) - (i = xc.length);\r\n\r\n      // Append zeros to xc if shorter.\r\n      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n      if (b > 0) for (; b--; xc[i++] = 0);\r\n      b = BASE - 1;\r\n\r\n      // Subtract yc from xc.\r\n      for (; j > a;) {\r\n\r\n        if (xc[--j] < yc[j]) {\r\n          for (i = j; i && !xc[--i]; xc[i] = b);\r\n          --xc[i];\r\n          xc[j] += BASE;\r\n        }\r\n\r\n        xc[j] -= yc[j];\r\n      }\r\n\r\n      // Remove leading zeros and adjust exponent accordingly.\r\n      for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n      // Zero?\r\n      if (!xc[0]) {\r\n\r\n        // Following IEEE 754 (2008) 6.3,\r\n        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n        y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n        y.c = [y.e = 0];\r\n        return y;\r\n      }\r\n\r\n      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n      // for finite x and y.\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     *   n % 0 =  N\r\n     *   n % N =  N\r\n     *   n % I =  n\r\n     *   0 % n =  0\r\n     *  -0 % n = -0\r\n     *   0 % 0 =  N\r\n     *   0 % N =  N\r\n     *   0 % I =  0\r\n     *   N % n =  N\r\n     *   N % 0 =  N\r\n     *   N % N =  N\r\n     *   N % I =  N\r\n     *   I % n =  N\r\n     *   I % 0 =  N\r\n     *   I % N =  N\r\n     *   I % I =  N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n     * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n     */\r\n    P.modulo = P.mod = function (y, b) {\r\n      var q, s,\r\n        x = this;\r\n\r\n      y = new BigNumber(y, b);\r\n\r\n      // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n      if (!x.c || !y.s || y.c && !y.c[0]) {\r\n        return new BigNumber(NaN);\r\n\r\n      // Return x if y is Infinity or x is zero.\r\n      } else if (!y.c || x.c && !x.c[0]) {\r\n        return new BigNumber(x);\r\n      }\r\n\r\n      if (MODULO_MODE == 9) {\r\n\r\n        // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n        // r = x - qy    where  0 <= r < abs(y)\r\n        s = y.s;\r\n        y.s = 1;\r\n        q = div(x, y, 0, 3);\r\n        y.s = s;\r\n        q.s *= s;\r\n      } else {\r\n        q = div(x, y, 0, MODULO_MODE);\r\n      }\r\n\r\n      y = x.minus(q.times(y));\r\n\r\n      // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n      return y;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n * 0 = 0\r\n     *  n * N = N\r\n     *  n * I = I\r\n     *  0 * n = 0\r\n     *  0 * 0 = 0\r\n     *  0 * N = N\r\n     *  0 * I = N\r\n     *  N * n = N\r\n     *  N * 0 = N\r\n     *  N * N = N\r\n     *  N * I = N\r\n     *  I * n = I\r\n     *  I * 0 = N\r\n     *  I * N = N\r\n     *  I * I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n     * of BigNumber(y, b).\r\n     */\r\n    P.multipliedBy = P.times = function (y, b) {\r\n      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n        base, sqrtBase,\r\n        x = this,\r\n        xc = x.c,\r\n        yc = (y = new BigNumber(y, b)).c;\r\n\r\n      // Either NaN, ±Infinity or ±0?\r\n      if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n        // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n          y.c = y.e = y.s = null;\r\n        } else {\r\n          y.s *= x.s;\r\n\r\n          // Return ±Infinity if either is ±Infinity.\r\n          if (!xc || !yc) {\r\n            y.c = y.e = null;\r\n\r\n          // Return ±0 if either is ±0.\r\n          } else {\r\n            y.c = [0];\r\n            y.e = 0;\r\n          }\r\n        }\r\n\r\n        return y;\r\n      }\r\n\r\n      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n      y.s *= x.s;\r\n      xcL = xc.length;\r\n      ycL = yc.length;\r\n\r\n      // Ensure xc points to longer array and xcL to its length.\r\n      if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\r\n\r\n      // Initialise the result array with zeros.\r\n      for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n      base = BASE;\r\n      sqrtBase = SQRT_BASE;\r\n\r\n      for (i = ycL; --i >= 0;) {\r\n        c = 0;\r\n        ylo = yc[i] % sqrtBase;\r\n        yhi = yc[i] / sqrtBase | 0;\r\n\r\n        for (k = xcL, j = i + k; j > i;) {\r\n          xlo = xc[--k] % sqrtBase;\r\n          xhi = xc[k] / sqrtBase | 0;\r\n          m = yhi * xlo + xhi * ylo;\r\n          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n          zc[j--] = xlo % base;\r\n        }\r\n\r\n        zc[j] = c;\r\n      }\r\n\r\n      if (c) {\r\n        ++e;\r\n      } else {\r\n        zc.splice(0, 1);\r\n      }\r\n\r\n      return normalise(y, zc, e);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n     * i.e. multiplied by -1.\r\n     */\r\n    P.negated = function () {\r\n      var x = new BigNumber(this);\r\n      x.s = -x.s || null;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n + 0 = n\r\n     *  n + N = N\r\n     *  n + I = I\r\n     *  0 + n = n\r\n     *  0 + 0 = 0\r\n     *  0 + N = N\r\n     *  0 + I = I\r\n     *  N + n = N\r\n     *  N + 0 = N\r\n     *  N + N = N\r\n     *  N + I = N\r\n     *  I + n = I\r\n     *  I + 0 = I\r\n     *  I + N = N\r\n     *  I + I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.plus = function (y, b) {\r\n      var t,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n       if (a != b) {\r\n        y.s = -b;\r\n        return x.minus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Return ±Infinity if either ±Infinity.\r\n        if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n        // Either zero?\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n      if (a = xe - ye) {\r\n        if (a > 0) {\r\n          ye = xe;\r\n          t = yc;\r\n        } else {\r\n          a = -a;\r\n          t = xc;\r\n        }\r\n\r\n        t.reverse();\r\n        for (; a--; t.push(0));\r\n        t.reverse();\r\n      }\r\n\r\n      a = xc.length;\r\n      b = yc.length;\r\n\r\n      // Point xc to the longer array, and b to the shorter length.\r\n      if (a - b < 0) t = yc, yc = xc, xc = t, b = a;\r\n\r\n      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n      for (a = 0; b;) {\r\n        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n      }\r\n\r\n      if (a) {\r\n        xc = [a].concat(xc);\r\n        ++ye;\r\n      }\r\n\r\n      // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n      // ye = MAX_EXP + 1 possible\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     * If sd is undefined or null or true or false, return the number of significant digits of\r\n     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     * If sd is true include integer-part trailing zeros in the count.\r\n     *\r\n     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n     *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.precision = P.sd = function (sd, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (sd != null && sd !== !!sd) {\r\n        intCheck(sd, 1, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), sd, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      v = c.length - 1;\r\n      n = v * LOG_BASE + 1;\r\n\r\n      if (v = c[v]) {\r\n\r\n        // Subtract the number of trailing zeros of the last element.\r\n        for (; v % 10 == 0; v /= 10, n--);\r\n\r\n        // Add the number of digits of the first element.\r\n        for (v = c[0]; v >= 10; v /= 10, n++);\r\n      }\r\n\r\n      if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n     *\r\n     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n     */\r\n    P.shiftedBy = function (k) {\r\n      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n      return this.times('1e' + k);\r\n    };\r\n\r\n\r\n    /*\r\n     *  sqrt(-n) =  N\r\n     *  sqrt(N) =  N\r\n     *  sqrt(-I) =  N\r\n     *  sqrt(I) =  I\r\n     *  sqrt(0) =  0\r\n     *  sqrt(-0) = -0\r\n     *\r\n     * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.squareRoot = P.sqrt = function () {\r\n      var m, n, r, rep, t,\r\n        x = this,\r\n        c = x.c,\r\n        s = x.s,\r\n        e = x.e,\r\n        dp = DECIMAL_PLACES + 4,\r\n        half = new BigNumber('0.5');\r\n\r\n      // Negative/NaN/Infinity/zero?\r\n      if (s !== 1 || !c || !c[0]) {\r\n        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n      }\r\n\r\n      // Initial estimate.\r\n      s = Math.sqrt(+valueOf(x));\r\n\r\n      // Math.sqrt underflow/overflow?\r\n      // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n      if (s == 0 || s == 1 / 0) {\r\n        n = coeffToString(c);\r\n        if ((n.length + e) % 2 == 0) n += '0';\r\n        s = Math.sqrt(+n);\r\n        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n        if (s == 1 / 0) {\r\n          n = '5e' + e;\r\n        } else {\r\n          n = s.toExponential();\r\n          n = n.slice(0, n.indexOf('e') + 1) + e;\r\n        }\r\n\r\n        r = new BigNumber(n);\r\n      } else {\r\n        r = new BigNumber(s + '');\r\n      }\r\n\r\n      // Check for zero.\r\n      // r could be zero if MIN_EXP is changed after the this value was created.\r\n      // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n      // coeffToString to throw.\r\n      if (r.c[0]) {\r\n        e = r.e;\r\n        s = e + dp;\r\n        if (s < 3) s = 0;\r\n\r\n        // Newton-Raphson iteration.\r\n        for (; ;) {\r\n          t = r;\r\n          r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n          if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n            // The exponent of r may here be one less than the final result exponent,\r\n            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n            // are indexed correctly.\r\n            if (r.e < e) --s;\r\n            n = n.slice(s - 3, s + 1);\r\n\r\n            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n            // iteration.\r\n            if (n == '9999' || !rep && n == '4999') {\r\n\r\n              // On the first iteration only, check to see if rounding up gives the\r\n              // exact result as the nines may infinitely repeat.\r\n              if (!rep) {\r\n                round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n                if (t.times(t).eq(x)) {\r\n                  r = t;\r\n                  break;\r\n                }\r\n              }\r\n\r\n              dp += 4;\r\n              s += 4;\r\n              rep = 1;\r\n            } else {\r\n\r\n              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n              // result. If not, then there are further digits and m will be truthy.\r\n              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n                // Truncate to the first rounding digit.\r\n                round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n                m = !r.times(r).eq(x);\r\n              }\r\n\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in exponential notation and\r\n     * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toExponential = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp++;\r\n      }\r\n      return format(this, dp, rm, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n     * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toFixed = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp = dp + this.e + 1;\r\n      }\r\n      return format(this, dp, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n     * of the format or FORMAT object (see BigNumber.set).\r\n     *\r\n     * The formatting object may contain some or all of the properties shown below.\r\n     *\r\n     * FORMAT = {\r\n     *   prefix: '',\r\n     *   groupSize: 3,\r\n     *   secondaryGroupSize: 0,\r\n     *   groupSeparator: ',',\r\n     *   decimalSeparator: '.',\r\n     *   fractionGroupSize: 0,\r\n     *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n     *   suffix: ''\r\n     * };\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     * [format] {object} Formatting options. See FORMAT pbject above.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     * '[BigNumber Error] Argument not an object: {format}'\r\n     */\r\n    P.toFormat = function (dp, rm, format) {\r\n      var str,\r\n        x = this;\r\n\r\n      if (format == null) {\r\n        if (dp != null && rm && typeof rm == 'object') {\r\n          format = rm;\r\n          rm = null;\r\n        } else if (dp && typeof dp == 'object') {\r\n          format = dp;\r\n          dp = rm = null;\r\n        } else {\r\n          format = FORMAT;\r\n        }\r\n      } else if (typeof format != 'object') {\r\n        throw Error\r\n          (bignumberError + 'Argument not an object: ' + format);\r\n      }\r\n\r\n      str = x.toFixed(dp, rm);\r\n\r\n      if (x.c) {\r\n        var i,\r\n          arr = str.split('.'),\r\n          g1 = +format.groupSize,\r\n          g2 = +format.secondaryGroupSize,\r\n          groupSeparator = format.groupSeparator || '',\r\n          intPart = arr[0],\r\n          fractionPart = arr[1],\r\n          isNeg = x.s < 0,\r\n          intDigits = isNeg ? intPart.slice(1) : intPart,\r\n          len = intDigits.length;\r\n\r\n        if (g2) i = g1, g1 = g2, g2 = i, len -= i;\r\n\r\n        if (g1 > 0 && len > 0) {\r\n          i = len % g1 || g1;\r\n          intPart = intDigits.substr(0, i);\r\n          for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n          if (isNeg) intPart = '-' + intPart;\r\n        }\r\n\r\n        str = fractionPart\r\n         ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n          ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n           '$&' + (format.fractionGroupSeparator || ''))\r\n          : fractionPart)\r\n         : intPart;\r\n      }\r\n\r\n      return (format.prefix || '') + str + (format.suffix || '');\r\n    };\r\n\r\n\r\n    /*\r\n     * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n     * fraction with an integer numerator and an integer denominator.\r\n     * The denominator will be a positive non-zero value less than or equal to the specified\r\n     * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n     * the lowest value necessary to represent the number exactly.\r\n     *\r\n     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n     *\r\n     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n     */\r\n    P.toFraction = function (md) {\r\n      var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n        x = this,\r\n        xc = x.c;\r\n\r\n      if (md != null) {\r\n        n = new BigNumber(md);\r\n\r\n        // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n          throw Error\r\n            (bignumberError + 'Argument ' +\r\n              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n        }\r\n      }\r\n\r\n      if (!xc) return new BigNumber(x);\r\n\r\n      d = new BigNumber(ONE);\r\n      n1 = d0 = new BigNumber(ONE);\r\n      d1 = n0 = new BigNumber(ONE);\r\n      s = coeffToString(xc);\r\n\r\n      // Determine initial denominator.\r\n      // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n      e = d.e = s.length - x.e - 1;\r\n      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n      exp = MAX_EXP;\r\n      MAX_EXP = 1 / 0;\r\n      n = new BigNumber(s);\r\n\r\n      // n0 = d1 = 0\r\n      n0.c[0] = 0;\r\n\r\n      for (; ;)  {\r\n        q = div(n, d, 0, 1);\r\n        d2 = d0.plus(q.times(d1));\r\n        if (d2.comparedTo(md) == 1) break;\r\n        d0 = d1;\r\n        d1 = d2;\r\n        n1 = n0.plus(q.times(d2 = n1));\r\n        n0 = d2;\r\n        d = n.minus(q.times(d2 = d));\r\n        n = d2;\r\n      }\r\n\r\n      d2 = div(md.minus(d0), d1, 0, 1);\r\n      n0 = n0.plus(d2.times(n1));\r\n      d0 = d0.plus(d2.times(d1));\r\n      n0.s = n1.s = x.s;\r\n      e = e * 2;\r\n\r\n      // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n      MAX_EXP = exp;\r\n\r\n      return r;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return the value of this BigNumber converted to a number primitive.\r\n     */\r\n    P.toNumber = function () {\r\n      return +valueOf(this);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n     * necessary to represent the integer part of the value in fixed-point notation, then use\r\n     * exponential notation.\r\n     *\r\n     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.toPrecision = function (sd, rm) {\r\n      if (sd != null) intCheck(sd, 1, MAX);\r\n      return format(this, sd, rm, 2);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n     * TO_EXP_NEG, return exponential notation.\r\n     *\r\n     * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n     *\r\n     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n     */\r\n    P.toString = function (b) {\r\n      var str,\r\n        n = this,\r\n        s = n.s,\r\n        e = n.e;\r\n\r\n      // Infinity or NaN?\r\n      if (e === null) {\r\n        if (s) {\r\n          str = 'Infinity';\r\n          if (s < 0) str = '-' + str;\r\n        } else {\r\n          str = 'NaN';\r\n        }\r\n      } else {\r\n        if (b == null) {\r\n          str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n           ? toExponential(coeffToString(n.c), e)\r\n           : toFixedPoint(coeffToString(n.c), e, '0');\r\n        } else if (b === 10) {\r\n          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n          str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n        } else {\r\n          intCheck(b, 2, ALPHABET.length, 'Base');\r\n          str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n        }\r\n\r\n        if (s < 0 && n.c[0]) str = '-' + str;\r\n      }\r\n\r\n      return str;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return as toString, but do not accept a base argument, and include the minus sign for\r\n     * negative zero.\r\n     */\r\n    P.valueOf = P.toJSON = function () {\r\n      return valueOf(this);\r\n    };\r\n\r\n\r\n    P._isBigNumber = true;\r\n\r\n    if (configObject != null) BigNumber.set(configObject);\r\n\r\n    return BigNumber;\r\n  }\r\n\r\n\r\n  // PRIVATE HELPER FUNCTIONS\r\n\r\n  // These functions don't need access to variables,\r\n  // e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\r\n\r\n\r\n  function bitFloor(n) {\r\n    var i = n | 0;\r\n    return n > 0 || n === i ? i : i - 1;\r\n  }\r\n\r\n\r\n  // Return a coefficient array as a string of base 10 digits.\r\n  function coeffToString(a) {\r\n    var s, z,\r\n      i = 1,\r\n      j = a.length,\r\n      r = a[0] + '';\r\n\r\n    for (; i < j;) {\r\n      s = a[i++] + '';\r\n      z = LOG_BASE - s.length;\r\n      for (; z--; s = '0' + s);\r\n      r += s;\r\n    }\r\n\r\n    // Determine trailing zeros.\r\n    for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n    return r.slice(0, j + 1 || 1);\r\n  }\r\n\r\n\r\n  // Compare the value of BigNumbers x and y.\r\n  function compare(x, y) {\r\n    var a, b,\r\n      xc = x.c,\r\n      yc = y.c,\r\n      i = x.s,\r\n      j = y.s,\r\n      k = x.e,\r\n      l = y.e;\r\n\r\n    // Either NaN?\r\n    if (!i || !j) return null;\r\n\r\n    a = xc && !xc[0];\r\n    b = yc && !yc[0];\r\n\r\n    // Either zero?\r\n    if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n    // Signs differ?\r\n    if (i != j) return i;\r\n\r\n    a = i < 0;\r\n    b = k == l;\r\n\r\n    // Either Infinity?\r\n    if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n    // Compare exponents.\r\n    if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n    j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n    // Compare digit by digit.\r\n    for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n    // Compare lengths.\r\n    return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n  }\r\n\r\n\r\n  /*\r\n   * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n   */\r\n  function intCheck(n, min, max, name) {\r\n    if (n < min || n > max || n !== mathfloor(n)) {\r\n      throw Error\r\n       (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n         ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n         : ' not a primitive number: ') + String(n));\r\n    }\r\n  }\r\n\r\n\r\n  // Assumes finite n.\r\n  function isOdd(n) {\r\n    var k = n.c.length - 1;\r\n    return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n  }\r\n\r\n\r\n  function toExponential(str, e) {\r\n    return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n     (e < 0 ? 'e' : 'e+') + e;\r\n  }\r\n\r\n\r\n  function toFixedPoint(str, e, z) {\r\n    var len, zs;\r\n\r\n    // Negative exponent?\r\n    if (e < 0) {\r\n\r\n      // Prepend zeros.\r\n      for (zs = z + '.'; ++e; zs += z);\r\n      str = zs + str;\r\n\r\n    // Positive exponent\r\n    } else {\r\n      len = str.length;\r\n\r\n      // Append zeros.\r\n      if (++e > len) {\r\n        for (zs = z, e -= len; --e; zs += z);\r\n        str += zs;\r\n      } else if (e < len) {\r\n        str = str.slice(0, e) + '.' + str.slice(e);\r\n      }\r\n    }\r\n\r\n    return str;\r\n  }\r\n\r\n\r\n  // EXPORT\r\n\r\n\r\n  BigNumber = clone();\r\n  BigNumber['default'] = BigNumber.BigNumber = BigNumber;\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () { return BigNumber; });\r\n\r\n  // Node.js and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    module.exports = BigNumber;\r\n\r\n  // Browser.\r\n  } else {\r\n    if (!globalObject) {\r\n      globalObject = typeof self != 'undefined' && self ? self : window;\r\n    }\r\n\r\n    globalObject.BigNumber = BigNumber;\r\n  }\r\n})(this);\r\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://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 customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nvar K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               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 * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    var arr = new Uint8Array(1)\n    var proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  var buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\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  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  var valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  var b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(\n      value[Symbol.toPrimitive]('string'), encodingOrOffset, length\n    )\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\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(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(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 interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(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(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\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(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(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  var length = byteLength(string, encoding) | 0\n  var buf = createBuffer(length)\n\n  var actual = buf.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    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  var buf = createBuffer(length)\n  for (var i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    var copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  var buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    var buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.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 === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\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 (!Array.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 (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        Buffer.from(buf).copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\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 (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  var len = string.length\n  var mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && 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        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) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\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 coercion 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// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\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\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.toLocaleString = Buffer.prototype.toString\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  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\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 (numberIsNaN(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 (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  var strLen = string.length\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 (numberIsNaN(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 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  } 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      case 'latin1':\n      case 'binary':\n        return asciiWrite(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)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 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 += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (var i = 0; i < bytes.length - 1; 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 = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\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 =\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 =\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 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\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 =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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 =\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 =\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 =\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  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\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  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\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  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\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  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\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 (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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\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  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\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  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\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  value = +value\n  offset = offset >>> 0\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  value = +value\n  offset = offset >>> 0\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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\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('Index out of range')\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\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\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 (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    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\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      : Buffer.from(val, encoding)\n    var len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\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 takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().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 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\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nvar hexSliceLookupTable = (function () {\n  var alphabet = '0123456789abcdef'\n  var table = new Array(256)\n  for (var i = 0; i < 16; ++i) {\n    var i16 = i * 16\n    for (var j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n","'use strict'\n\nconst Bignumber = require('bignumber.js').BigNumber\n\nexports.MT = {\n  POS_INT: 0,\n  NEG_INT: 1,\n  BYTE_STRING: 2,\n  UTF8_STRING: 3,\n  ARRAY: 4,\n  MAP: 5,\n  TAG: 6,\n  SIMPLE_FLOAT: 7\n}\n\nexports.TAG = {\n  DATE_STRING: 0,\n  DATE_EPOCH: 1,\n  POS_BIGINT: 2,\n  NEG_BIGINT: 3,\n  DECIMAL_FRAC: 4,\n  BIGFLOAT: 5,\n  BASE64URL_EXPECTED: 21,\n  BASE64_EXPECTED: 22,\n  BASE16_EXPECTED: 23,\n  CBOR: 24,\n  URI: 32,\n  BASE64URL: 33,\n  BASE64: 34,\n  REGEXP: 35,\n  MIME: 36\n}\n\nexports.NUMBYTES = {\n  ZERO: 0,\n  ONE: 24,\n  TWO: 25,\n  FOUR: 26,\n  EIGHT: 27,\n  INDEFINITE: 31\n}\n\nexports.SIMPLE = {\n  FALSE: 20,\n  TRUE: 21,\n  NULL: 22,\n  UNDEFINED: 23\n}\n\nexports.SYMS = {\n  NULL: Symbol('null'),\n  UNDEFINED: Symbol('undef'),\n  PARENT: Symbol('parent'),\n  BREAK: Symbol('break'),\n  STREAM: Symbol('stream')\n}\n\nexports.SHIFT32 = Math.pow(2, 32)\nexports.SHIFT16 = Math.pow(2, 16)\n\nexports.MAX_SAFE_HIGH = 0x1fffff\nexports.NEG_ONE = new Bignumber(-1)\nexports.TEN = new Bignumber(10)\nexports.TWO = new Bignumber(2)\n\nexports.PARENT = {\n  ARRAY: 0,\n  OBJECT: 1,\n  MAP: 2,\n  TAG: 3,\n  BYTE_STRING: 4,\n  UTF8_STRING: 5\n}\n","/* eslint-disable */\n\nmodule.exports = function decodeAsm (stdlib, foreign, buffer) {\n  'use asm'\n\n  // -- Imports\n\n  var heap = new stdlib.Uint8Array(buffer)\n  // var log = foreign.log\n  var pushInt = foreign.pushInt\n  var pushInt32 = foreign.pushInt32\n  var pushInt32Neg = foreign.pushInt32Neg\n  var pushInt64 = foreign.pushInt64\n  var pushInt64Neg = foreign.pushInt64Neg\n  var pushFloat = foreign.pushFloat\n  var pushFloatSingle = foreign.pushFloatSingle\n  var pushFloatDouble = foreign.pushFloatDouble\n  var pushTrue = foreign.pushTrue\n  var pushFalse = foreign.pushFalse\n  var pushUndefined = foreign.pushUndefined\n  var pushNull = foreign.pushNull\n  var pushInfinity = foreign.pushInfinity\n  var pushInfinityNeg = foreign.pushInfinityNeg\n  var pushNaN = foreign.pushNaN\n  var pushNaNNeg = foreign.pushNaNNeg\n\n  var pushArrayStart = foreign.pushArrayStart\n  var pushArrayStartFixed = foreign.pushArrayStartFixed\n  var pushArrayStartFixed32 = foreign.pushArrayStartFixed32\n  var pushArrayStartFixed64 = foreign.pushArrayStartFixed64\n  var pushObjectStart = foreign.pushObjectStart\n  var pushObjectStartFixed = foreign.pushObjectStartFixed\n  var pushObjectStartFixed32 = foreign.pushObjectStartFixed32\n  var pushObjectStartFixed64 = foreign.pushObjectStartFixed64\n\n  var pushByteString = foreign.pushByteString\n  var pushByteStringStart = foreign.pushByteStringStart\n  var pushUtf8String = foreign.pushUtf8String\n  var pushUtf8StringStart = foreign.pushUtf8StringStart\n\n  var pushSimpleUnassigned = foreign.pushSimpleUnassigned\n\n  var pushTagStart = foreign.pushTagStart\n  var pushTagStart4 = foreign.pushTagStart4\n  var pushTagStart8 = foreign.pushTagStart8\n  var pushTagUnassigned = foreign.pushTagUnassigned\n\n  var pushBreak = foreign.pushBreak\n\n  var pow = stdlib.Math.pow\n\n  // -- Constants\n\n\n  // -- Mutable Variables\n\n  var offset = 0\n  var inputLength = 0\n  var code = 0\n\n  // Decode a cbor string represented as Uint8Array\n  // which is allocated on the heap from 0 to inputLength\n  //\n  // input - Int\n  //\n  // Returns Code - Int,\n  // Success = 0\n  // Error > 0\n  function parse (input) {\n    input = input | 0\n\n    offset = 0\n    inputLength = input\n\n    while ((offset | 0) < (inputLength | 0)) {\n      code = jumpTable[heap[offset] & 255](heap[offset] | 0) | 0\n\n      if ((code | 0) > 0) {\n        break\n      }\n    }\n\n    return code | 0\n  }\n\n  // -- Helper Function\n\n  function checkOffset (n) {\n    n = n | 0\n\n    if ((((offset | 0) + (n | 0)) | 0) < (inputLength | 0)) {\n      return 0\n    }\n\n    return 1\n  }\n\n  function readUInt16 (n) {\n    n = n | 0\n\n    return (\n      (heap[n | 0] << 8) | heap[(n + 1) | 0]\n    ) | 0\n  }\n\n  function readUInt32 (n) {\n    n = n | 0\n\n    return (\n      (heap[n | 0] << 24) | (heap[(n + 1) | 0] << 16) | (heap[(n + 2) | 0] << 8) | heap[(n + 3) | 0]\n    ) | 0\n  }\n\n  // -- Initial Byte Handlers\n\n  function INT_P (octet) {\n    octet = octet | 0\n\n    pushInt(octet | 0)\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function UINT_P_8 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(1) | 0) {\n      return 1\n    }\n\n    pushInt(heap[(offset + 1) | 0] | 0)\n\n    offset = (offset + 2) | 0\n\n    return 0\n  }\n\n  function UINT_P_16 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(2) | 0) {\n      return 1\n    }\n\n    pushInt(\n      readUInt16((offset + 1) | 0) | 0\n    )\n\n    offset = (offset + 3) | 0\n\n    return 0\n  }\n\n  function UINT_P_32 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(4) | 0) {\n      return 1\n    }\n\n    pushInt32(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0\n    )\n\n    offset = (offset + 5) | 0\n\n    return 0\n  }\n\n  function UINT_P_64 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(8) | 0) {\n      return 1\n    }\n\n    pushInt64(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0,\n      readUInt16((offset + 5) | 0) | 0,\n      readUInt16((offset + 7) | 0) | 0\n    )\n\n    offset = (offset + 9) | 0\n\n    return 0\n  }\n\n  function INT_N (octet) {\n    octet = octet | 0\n\n    pushInt((-1 - ((octet - 32) | 0)) | 0)\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function UINT_N_8 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(1) | 0) {\n      return 1\n    }\n\n    pushInt(\n      (-1 - (heap[(offset + 1) | 0] | 0)) | 0\n    )\n\n    offset = (offset + 2) | 0\n\n    return 0\n  }\n\n  function UINT_N_16 (octet) {\n    octet = octet | 0\n\n    var val = 0\n\n    if (checkOffset(2) | 0) {\n      return 1\n    }\n\n    val = readUInt16((offset + 1) | 0) | 0\n    pushInt((-1 - (val | 0)) | 0)\n\n    offset = (offset + 3) | 0\n\n    return 0\n  }\n\n  function UINT_N_32 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(4) | 0) {\n      return 1\n    }\n\n    pushInt32Neg(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0\n    )\n\n    offset = (offset + 5) | 0\n\n    return 0\n  }\n\n  function UINT_N_64 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(8) | 0) {\n      return 1\n    }\n\n    pushInt64Neg(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0,\n      readUInt16((offset + 5) | 0) | 0,\n      readUInt16((offset + 7) | 0) | 0\n    )\n\n    offset = (offset + 9) | 0\n\n    return 0\n  }\n\n  function BYTE_STRING (octet) {\n    octet = octet | 0\n\n    var start = 0\n    var end = 0\n    var step = 0\n\n    step = (octet - 64) | 0\n    if (checkOffset(step | 0) | 0) {\n      return 1\n    }\n\n    start = (offset + 1) | 0\n    end = (((offset + 1) | 0) + (step | 0)) | 0\n\n    pushByteString(start | 0, end | 0)\n\n    offset = end | 0\n\n    return 0\n  }\n\n  function BYTE_STRING_8 (octet) {\n    octet = octet | 0\n\n    var start = 0\n    var end = 0\n    var length = 0\n\n    if (checkOffset(1) | 0) {\n      return 1\n    }\n\n    length = heap[(offset + 1) | 0] | 0\n    start = (offset + 2) | 0\n    end = (((offset + 2) | 0) + (length | 0)) | 0\n\n    if (checkOffset((length + 1) | 0) | 0) {\n      return 1\n    }\n\n    pushByteString(start | 0, end | 0)\n\n    offset = end | 0\n\n    return 0\n  }\n\n  function BYTE_STRING_16 (octet) {\n    octet = octet | 0\n\n    var start = 0\n    var end = 0\n    var length = 0\n\n    if (checkOffset(2) | 0) {\n      return 1\n    }\n\n    length = readUInt16((offset + 1) | 0) | 0\n    start = (offset + 3) | 0\n    end = (((offset + 3) | 0) + (length | 0)) | 0\n\n\n    if (checkOffset((length + 2) | 0) | 0) {\n      return 1\n    }\n\n    pushByteString(start | 0, end | 0)\n\n    offset = end | 0\n\n    return 0\n  }\n\n  function BYTE_STRING_32 (octet) {\n    octet = octet | 0\n\n    var start = 0\n    var end = 0\n    var length = 0\n\n    if (checkOffset(4) | 0) {\n      return 1\n    }\n\n    length = readUInt32((offset + 1) | 0) | 0\n    start = (offset + 5) | 0\n    end = (((offset + 5) | 0) + (length | 0)) | 0\n\n\n    if (checkOffset((length + 4) | 0) | 0) {\n      return 1\n    }\n\n    pushByteString(start | 0, end | 0)\n\n    offset = end | 0\n\n    return 0\n  }\n\n  function BYTE_STRING_64 (octet) {\n    // NOT IMPLEMENTED\n    octet = octet | 0\n\n    return 1\n  }\n\n  function BYTE_STRING_BREAK (octet) {\n    octet = octet | 0\n\n    pushByteStringStart()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function UTF8_STRING (octet) {\n    octet = octet | 0\n\n    var start = 0\n    var end = 0\n    var step = 0\n\n    step = (octet - 96) | 0\n\n    if (checkOffset(step | 0) | 0) {\n      return 1\n    }\n\n    start = (offset + 1) | 0\n    end = (((offset + 1) | 0) + (step | 0)) | 0\n\n    pushUtf8String(start | 0, end | 0)\n\n    offset = end | 0\n\n    return 0\n  }\n\n  function UTF8_STRING_8 (octet) {\n    octet = octet | 0\n\n    var start = 0\n    var end = 0\n    var length = 0\n\n    if (checkOffset(1) | 0) {\n      return 1\n    }\n\n    length = heap[(offset + 1) | 0] | 0\n    start = (offset + 2) | 0\n    end = (((offset + 2) | 0) + (length | 0)) | 0\n\n    if (checkOffset((length + 1) | 0) | 0) {\n      return 1\n    }\n\n    pushUtf8String(start | 0, end | 0)\n\n    offset = end | 0\n\n    return 0\n  }\n\n  function UTF8_STRING_16 (octet) {\n    octet = octet | 0\n\n    var start = 0\n    var end = 0\n    var length = 0\n\n    if (checkOffset(2) | 0) {\n      return 1\n    }\n\n    length = readUInt16((offset + 1) | 0) | 0\n    start = (offset + 3) | 0\n    end = (((offset + 3) | 0) + (length | 0)) | 0\n\n    if (checkOffset((length + 2) | 0) | 0) {\n      return 1\n    }\n\n    pushUtf8String(start | 0, end | 0)\n\n    offset = end | 0\n\n    return 0\n  }\n\n  function UTF8_STRING_32 (octet) {\n    octet = octet | 0\n\n    var start = 0\n    var end = 0\n    var length = 0\n\n    if (checkOffset(4) | 0) {\n      return 1\n    }\n\n    length = readUInt32((offset + 1) | 0) | 0\n    start = (offset + 5) | 0\n    end = (((offset + 5) | 0) + (length | 0)) | 0\n\n    if (checkOffset((length + 4) | 0) | 0) {\n      return 1\n    }\n\n    pushUtf8String(start | 0, end | 0)\n\n    offset = end | 0\n\n    return 0\n  }\n\n  function UTF8_STRING_64 (octet) {\n    // NOT IMPLEMENTED\n    octet = octet | 0\n\n    return 1\n  }\n\n  function UTF8_STRING_BREAK (octet) {\n    octet = octet | 0\n\n    pushUtf8StringStart()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function ARRAY (octet) {\n    octet = octet | 0\n\n    pushArrayStartFixed((octet - 128) | 0)\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function ARRAY_8 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(1) | 0) {\n      return 1\n    }\n\n    pushArrayStartFixed(heap[(offset + 1) | 0] | 0)\n\n    offset = (offset + 2) | 0\n\n    return 0\n  }\n\n  function ARRAY_16 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(2) | 0) {\n      return 1\n    }\n\n    pushArrayStartFixed(\n      readUInt16((offset + 1) | 0) | 0\n    )\n\n    offset = (offset + 3) | 0\n\n    return 0\n  }\n\n  function ARRAY_32 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(4) | 0) {\n      return 1\n    }\n\n    pushArrayStartFixed32(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0\n    )\n\n    offset = (offset + 5) | 0\n\n    return 0\n  }\n\n  function ARRAY_64 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(8) | 0) {\n      return 1\n    }\n\n    pushArrayStartFixed64(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0,\n      readUInt16((offset + 5) | 0) | 0,\n      readUInt16((offset + 7) | 0) | 0\n    )\n\n    offset = (offset + 9) | 0\n\n    return 0\n  }\n\n  function ARRAY_BREAK (octet) {\n    octet = octet | 0\n\n    pushArrayStart()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function MAP (octet) {\n    octet = octet | 0\n\n    var step = 0\n\n    step = (octet - 160) | 0\n\n    if (checkOffset(step | 0) | 0) {\n      return 1\n    }\n\n    pushObjectStartFixed(step | 0)\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function MAP_8 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(1) | 0) {\n      return 1\n    }\n\n    pushObjectStartFixed(heap[(offset + 1) | 0] | 0)\n\n    offset = (offset + 2) | 0\n\n    return 0\n  }\n\n  function MAP_16 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(2) | 0) {\n      return 1\n    }\n\n    pushObjectStartFixed(\n      readUInt16((offset + 1) | 0) | 0\n    )\n\n    offset = (offset + 3) | 0\n\n    return 0\n  }\n\n  function MAP_32 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(4) | 0) {\n      return 1\n    }\n\n    pushObjectStartFixed32(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0\n    )\n\n    offset = (offset + 5) | 0\n\n    return 0\n  }\n\n  function MAP_64 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(8) | 0) {\n      return 1\n    }\n\n    pushObjectStartFixed64(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0,\n      readUInt16((offset + 5) | 0) | 0,\n      readUInt16((offset + 7) | 0) | 0\n    )\n\n    offset = (offset + 9) | 0\n\n    return 0\n  }\n\n  function MAP_BREAK (octet) {\n    octet = octet | 0\n\n    pushObjectStart()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function TAG_KNOWN (octet) {\n    octet = octet | 0\n\n    pushTagStart((octet - 192| 0) | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_BIGNUM_POS (octet) {\n    octet = octet | 0\n\n    pushTagStart(octet | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_BIGNUM_NEG (octet) {\n    octet = octet | 0\n\n    pushTagStart(octet | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_FRAC (octet) {\n    octet = octet | 0\n\n    pushTagStart(octet | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_BIGNUM_FLOAT (octet) {\n    octet = octet | 0\n\n    pushTagStart(octet | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_UNASSIGNED (octet) {\n    octet = octet | 0\n\n    pushTagStart((octet - 192| 0) | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_BASE64_URL (octet) {\n    octet = octet | 0\n\n    pushTagStart(octet | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_BASE64 (octet) {\n    octet = octet | 0\n\n    pushTagStart(octet | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_BASE16 (octet) {\n    octet = octet | 0\n\n    pushTagStart(octet | 0)\n\n    offset = (offset + 1 | 0)\n\n    return 0\n  }\n\n  function TAG_MORE_1 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(1) | 0) {\n      return 1\n    }\n\n    pushTagStart(heap[(offset + 1) | 0] | 0)\n\n    offset = (offset + 2 | 0)\n\n    return 0\n  }\n\n  function TAG_MORE_2 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(2) | 0) {\n      return 1\n    }\n\n    pushTagStart(\n      readUInt16((offset + 1) | 0) | 0\n    )\n\n    offset = (offset + 3 | 0)\n\n    return 0\n  }\n\n  function TAG_MORE_4 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(4) | 0) {\n      return 1\n    }\n\n    pushTagStart4(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0\n    )\n\n    offset = (offset + 5 | 0)\n\n    return 0\n  }\n\n  function TAG_MORE_8 (octet) {\n    octet = octet | 0\n\n    if (checkOffset(8) | 0) {\n      return 1\n    }\n\n    pushTagStart8(\n      readUInt16((offset + 1) | 0) | 0,\n      readUInt16((offset + 3) | 0) | 0,\n      readUInt16((offset + 5) | 0) | 0,\n      readUInt16((offset + 7) | 0) | 0\n    )\n\n    offset = (offset + 9 | 0)\n\n    return 0\n  }\n\n  function SIMPLE_UNASSIGNED (octet) {\n    octet = octet | 0\n\n    pushSimpleUnassigned(((octet | 0) - 224) | 0)\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function SIMPLE_FALSE (octet) {\n    octet = octet | 0\n\n    pushFalse()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function SIMPLE_TRUE (octet) {\n    octet = octet | 0\n\n    pushTrue()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function SIMPLE_NULL (octet) {\n    octet = octet | 0\n\n    pushNull()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function SIMPLE_UNDEFINED (octet) {\n    octet = octet | 0\n\n    pushUndefined()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  function SIMPLE_BYTE (octet) {\n    octet = octet | 0\n\n    if (checkOffset(1) | 0) {\n      return 1\n    }\n\n    pushSimpleUnassigned(heap[(offset + 1) | 0] | 0)\n\n    offset = (offset + 2)  | 0\n\n    return 0\n  }\n\n  function SIMPLE_FLOAT_HALF (octet) {\n    octet = octet | 0\n\n    var f = 0\n    var g = 0\n    var sign = 1.0\n    var exp = 0.0\n    var mant = 0.0\n    var r = 0.0\n    if (checkOffset(2) | 0) {\n      return 1\n    }\n\n    f = heap[(offset + 1) | 0] | 0\n    g = heap[(offset + 2) | 0] | 0\n\n    if ((f | 0) & 0x80) {\n      sign = -1.0\n    }\n\n    exp = +(((f | 0) & 0x7C) >> 2)\n    mant = +((((f | 0) & 0x03) << 8) | g)\n\n    if (+exp == 0.0) {\n      pushFloat(+(\n        (+sign) * +5.9604644775390625e-8 * (+mant)\n      ))\n    } else if (+exp == 31.0) {\n      if (+sign == 1.0) {\n        if (+mant > 0.0) {\n          pushNaN()\n        } else {\n          pushInfinity()\n        }\n      } else {\n        if (+mant > 0.0) {\n          pushNaNNeg()\n        } else {\n          pushInfinityNeg()\n        }\n      }\n    } else {\n      pushFloat(+(\n        +sign * pow(+2, +(+exp - 25.0)) * +(1024.0 + mant)\n      ))\n    }\n\n    offset = (offset + 3) | 0\n\n    return 0\n  }\n\n  function SIMPLE_FLOAT_SINGLE (octet) {\n    octet = octet | 0\n\n    if (checkOffset(4) | 0) {\n      return 1\n    }\n\n    pushFloatSingle(\n      heap[(offset + 1) | 0] | 0,\n      heap[(offset + 2) | 0] | 0,\n      heap[(offset + 3) | 0] | 0,\n      heap[(offset + 4) | 0] | 0\n    )\n\n    offset = (offset + 5) | 0\n\n    return 0\n  }\n\n  function SIMPLE_FLOAT_DOUBLE (octet) {\n    octet = octet | 0\n\n    if (checkOffset(8) | 0) {\n      return 1\n    }\n\n    pushFloatDouble(\n      heap[(offset + 1) | 0] | 0,\n      heap[(offset + 2) | 0] | 0,\n      heap[(offset + 3) | 0] | 0,\n      heap[(offset + 4) | 0] | 0,\n      heap[(offset + 5) | 0] | 0,\n      heap[(offset + 6) | 0] | 0,\n      heap[(offset + 7) | 0] | 0,\n      heap[(offset + 8) | 0] | 0\n    )\n\n    offset = (offset + 9) | 0\n\n    return 0\n  }\n\n  function ERROR (octet) {\n    octet = octet | 0\n\n    return 1\n  }\n\n  function BREAK (octet) {\n    octet = octet | 0\n\n    pushBreak()\n\n    offset = (offset + 1) | 0\n\n    return 0\n  }\n\n  // -- Jump Table\n\n  var jumpTable = [\n    // Integer 0x00..0x17 (0..23)\n    INT_P, // 0x00\n    INT_P, // 0x01\n    INT_P, // 0x02\n    INT_P, // 0x03\n    INT_P, // 0x04\n    INT_P, // 0x05\n    INT_P, // 0x06\n    INT_P, // 0x07\n    INT_P, // 0x08\n    INT_P, // 0x09\n    INT_P, // 0x0A\n    INT_P, // 0x0B\n    INT_P, // 0x0C\n    INT_P, // 0x0D\n    INT_P, // 0x0E\n    INT_P, // 0x0F\n    INT_P, // 0x10\n    INT_P, // 0x11\n    INT_P, // 0x12\n    INT_P, // 0x13\n    INT_P, // 0x14\n    INT_P, // 0x15\n    INT_P, // 0x16\n    INT_P, // 0x17\n    // Unsigned integer (one-byte uint8_t follows)\n    UINT_P_8, // 0x18\n    // Unsigned integer (two-byte uint16_t follows)\n    UINT_P_16, // 0x19\n    // Unsigned integer (four-byte uint32_t follows)\n    UINT_P_32, // 0x1a\n    // Unsigned integer (eight-byte uint64_t follows)\n    UINT_P_64, // 0x1b\n    ERROR, // 0x1c\n    ERROR, // 0x1d\n    ERROR, // 0x1e\n    ERROR, // 0x1f\n    // Negative integer -1-0x00..-1-0x17 (-1..-24)\n    INT_N, // 0x20\n    INT_N, // 0x21\n    INT_N, // 0x22\n    INT_N, // 0x23\n    INT_N, // 0x24\n    INT_N, // 0x25\n    INT_N, // 0x26\n    INT_N, // 0x27\n    INT_N, // 0x28\n    INT_N, // 0x29\n    INT_N, // 0x2A\n    INT_N, // 0x2B\n    INT_N, // 0x2C\n    INT_N, // 0x2D\n    INT_N, // 0x2E\n    INT_N, // 0x2F\n    INT_N, // 0x30\n    INT_N, // 0x31\n    INT_N, // 0x32\n    INT_N, // 0x33\n    INT_N, // 0x34\n    INT_N, // 0x35\n    INT_N, // 0x36\n    INT_N, // 0x37\n    // Negative integer -1-n (one-byte uint8_t for n follows)\n    UINT_N_8, // 0x38\n    // Negative integer -1-n (two-byte uint16_t for n follows)\n    UINT_N_16, // 0x39\n    // Negative integer -1-n (four-byte uint32_t for nfollows)\n    UINT_N_32, // 0x3a\n    // Negative integer -1-n (eight-byte uint64_t for n follows)\n    UINT_N_64, // 0x3b\n    ERROR, // 0x3c\n    ERROR, // 0x3d\n    ERROR, // 0x3e\n    ERROR, // 0x3f\n    // byte string (0x00..0x17 bytes follow)\n    BYTE_STRING, // 0x40\n    BYTE_STRING, // 0x41\n    BYTE_STRING, // 0x42\n    BYTE_STRING, // 0x43\n    BYTE_STRING, // 0x44\n    BYTE_STRING, // 0x45\n    BYTE_STRING, // 0x46\n    BYTE_STRING, // 0x47\n    BYTE_STRING, // 0x48\n    BYTE_STRING, // 0x49\n    BYTE_STRING, // 0x4A\n    BYTE_STRING, // 0x4B\n    BYTE_STRING, // 0x4C\n    BYTE_STRING, // 0x4D\n    BYTE_STRING, // 0x4E\n    BYTE_STRING, // 0x4F\n    BYTE_STRING, // 0x50\n    BYTE_STRING, // 0x51\n    BYTE_STRING, // 0x52\n    BYTE_STRING, // 0x53\n    BYTE_STRING, // 0x54\n    BYTE_STRING, // 0x55\n    BYTE_STRING, // 0x56\n    BYTE_STRING, // 0x57\n    // byte string (one-byte uint8_t for n, and then n bytes follow)\n    BYTE_STRING_8, // 0x58\n    // byte string (two-byte uint16_t for n, and then n bytes follow)\n    BYTE_STRING_16, // 0x59\n    // byte string (four-byte uint32_t for n, and then n bytes follow)\n    BYTE_STRING_32, // 0x5a\n    // byte string (eight-byte uint64_t for n, and then n bytes follow)\n    BYTE_STRING_64, // 0x5b\n    ERROR, // 0x5c\n    ERROR, // 0x5d\n    ERROR, // 0x5e\n    // byte string, byte strings follow, terminated by \"break\"\n    BYTE_STRING_BREAK, // 0x5f\n    // UTF-8 string (0x00..0x17 bytes follow)\n    UTF8_STRING, // 0x60\n    UTF8_STRING, // 0x61\n    UTF8_STRING, // 0x62\n    UTF8_STRING, // 0x63\n    UTF8_STRING, // 0x64\n    UTF8_STRING, // 0x65\n    UTF8_STRING, // 0x66\n    UTF8_STRING, // 0x67\n    UTF8_STRING, // 0x68\n    UTF8_STRING, // 0x69\n    UTF8_STRING, // 0x6A\n    UTF8_STRING, // 0x6B\n    UTF8_STRING, // 0x6C\n    UTF8_STRING, // 0x6D\n    UTF8_STRING, // 0x6E\n    UTF8_STRING, // 0x6F\n    UTF8_STRING, // 0x70\n    UTF8_STRING, // 0x71\n    UTF8_STRING, // 0x72\n    UTF8_STRING, // 0x73\n    UTF8_STRING, // 0x74\n    UTF8_STRING, // 0x75\n    UTF8_STRING, // 0x76\n    UTF8_STRING, // 0x77\n    // UTF-8 string (one-byte uint8_t for n, and then n bytes follow)\n    UTF8_STRING_8, // 0x78\n    // UTF-8 string (two-byte uint16_t for n, and then n bytes follow)\n    UTF8_STRING_16, // 0x79\n    // UTF-8 string (four-byte uint32_t for n, and then n bytes follow)\n    UTF8_STRING_32, // 0x7a\n    // UTF-8 string (eight-byte uint64_t for n, and then n bytes follow)\n    UTF8_STRING_64, // 0x7b\n    // UTF-8 string, UTF-8 strings follow, terminated by \"break\"\n    ERROR, // 0x7c\n    ERROR, // 0x7d\n    ERROR, // 0x7e\n    UTF8_STRING_BREAK, // 0x7f\n    // array (0x00..0x17 data items follow)\n    ARRAY, // 0x80\n    ARRAY, // 0x81\n    ARRAY, // 0x82\n    ARRAY, // 0x83\n    ARRAY, // 0x84\n    ARRAY, // 0x85\n    ARRAY, // 0x86\n    ARRAY, // 0x87\n    ARRAY, // 0x88\n    ARRAY, // 0x89\n    ARRAY, // 0x8A\n    ARRAY, // 0x8B\n    ARRAY, // 0x8C\n    ARRAY, // 0x8D\n    ARRAY, // 0x8E\n    ARRAY, // 0x8F\n    ARRAY, // 0x90\n    ARRAY, // 0x91\n    ARRAY, // 0x92\n    ARRAY, // 0x93\n    ARRAY, // 0x94\n    ARRAY, // 0x95\n    ARRAY, // 0x96\n    ARRAY, // 0x97\n    // array (one-byte uint8_t fo, and then n data items follow)\n    ARRAY_8, // 0x98\n    // array (two-byte uint16_t for n, and then n data items follow)\n    ARRAY_16, // 0x99\n    // array (four-byte uint32_t for n, and then n data items follow)\n    ARRAY_32, // 0x9a\n    // array (eight-byte uint64_t for n, and then n data items follow)\n    ARRAY_64, // 0x9b\n    // array, data items follow, terminated by \"break\"\n    ERROR, // 0x9c\n    ERROR, // 0x9d\n    ERROR, // 0x9e\n    ARRAY_BREAK, // 0x9f\n    // map (0x00..0x17 pairs of data items follow)\n    MAP, // 0xa0\n    MAP, // 0xa1\n    MAP, // 0xa2\n    MAP, // 0xa3\n    MAP, // 0xa4\n    MAP, // 0xa5\n    MAP, // 0xa6\n    MAP, // 0xa7\n    MAP, // 0xa8\n    MAP, // 0xa9\n    MAP, // 0xaA\n    MAP, // 0xaB\n    MAP, // 0xaC\n    MAP, // 0xaD\n    MAP, // 0xaE\n    MAP, // 0xaF\n    MAP, // 0xb0\n    MAP, // 0xb1\n    MAP, // 0xb2\n    MAP, // 0xb3\n    MAP, // 0xb4\n    MAP, // 0xb5\n    MAP, // 0xb6\n    MAP, // 0xb7\n    // map (one-byte uint8_t for n, and then n pairs of data items follow)\n    MAP_8, // 0xb8\n    // map (two-byte uint16_t for n, and then n pairs of data items follow)\n    MAP_16, // 0xb9\n    // map (four-byte uint32_t for n, and then n pairs of data items follow)\n    MAP_32, // 0xba\n    // map (eight-byte uint64_t for n, and then n pairs of data items follow)\n    MAP_64, // 0xbb\n    ERROR, // 0xbc\n    ERROR, // 0xbd\n    ERROR, // 0xbe\n    // map, pairs of data items follow, terminated by \"break\"\n    MAP_BREAK, // 0xbf\n    // Text-based date/time (data item follows; see Section 2.4.1)\n    TAG_KNOWN, // 0xc0\n    // Epoch-based date/time (data item follows; see Section 2.4.1)\n    TAG_KNOWN, // 0xc1\n    // Positive bignum (data item \"byte string\" follows)\n    TAG_KNOWN, // 0xc2\n    // Negative bignum (data item \"byte string\" follows)\n    TAG_KNOWN, // 0xc3\n    // Decimal Fraction (data item \"array\" follows; see Section 2.4.3)\n    TAG_KNOWN, // 0xc4\n    // Bigfloat (data item \"array\" follows; see Section 2.4.3)\n    TAG_KNOWN, // 0xc5\n    // (tagged item)\n    TAG_UNASSIGNED, // 0xc6\n    TAG_UNASSIGNED, // 0xc7\n    TAG_UNASSIGNED, // 0xc8\n    TAG_UNASSIGNED, // 0xc9\n    TAG_UNASSIGNED, // 0xca\n    TAG_UNASSIGNED, // 0xcb\n    TAG_UNASSIGNED, // 0xcc\n    TAG_UNASSIGNED, // 0xcd\n    TAG_UNASSIGNED, // 0xce\n    TAG_UNASSIGNED, // 0xcf\n    TAG_UNASSIGNED, // 0xd0\n    TAG_UNASSIGNED, // 0xd1\n    TAG_UNASSIGNED, // 0xd2\n    TAG_UNASSIGNED, // 0xd3\n    TAG_UNASSIGNED, // 0xd4\n    // Expected Conversion (data item follows; see Section 2.4.4.2)\n    TAG_UNASSIGNED, // 0xd5\n    TAG_UNASSIGNED, // 0xd6\n    TAG_UNASSIGNED, // 0xd7\n    // (more tagged items, 1/2/4/8 bytes and then a data item follow)\n    TAG_MORE_1, // 0xd8\n    TAG_MORE_2, // 0xd9\n    TAG_MORE_4, // 0xda\n    TAG_MORE_8, // 0xdb\n    ERROR, // 0xdc\n    ERROR, // 0xdd\n    ERROR, // 0xde\n    ERROR, // 0xdf\n    // (simple value)\n    SIMPLE_UNASSIGNED, // 0xe0\n    SIMPLE_UNASSIGNED, // 0xe1\n    SIMPLE_UNASSIGNED, // 0xe2\n    SIMPLE_UNASSIGNED, // 0xe3\n    SIMPLE_UNASSIGNED, // 0xe4\n    SIMPLE_UNASSIGNED, // 0xe5\n    SIMPLE_UNASSIGNED, // 0xe6\n    SIMPLE_UNASSIGNED, // 0xe7\n    SIMPLE_UNASSIGNED, // 0xe8\n    SIMPLE_UNASSIGNED, // 0xe9\n    SIMPLE_UNASSIGNED, // 0xea\n    SIMPLE_UNASSIGNED, // 0xeb\n    SIMPLE_UNASSIGNED, // 0xec\n    SIMPLE_UNASSIGNED, // 0xed\n    SIMPLE_UNASSIGNED, // 0xee\n    SIMPLE_UNASSIGNED, // 0xef\n    SIMPLE_UNASSIGNED, // 0xf0\n    SIMPLE_UNASSIGNED, // 0xf1\n    SIMPLE_UNASSIGNED, // 0xf2\n    SIMPLE_UNASSIGNED, // 0xf3\n    // False\n    SIMPLE_FALSE, // 0xf4\n    // True\n    SIMPLE_TRUE, // 0xf5\n    // Null\n    SIMPLE_NULL, // 0xf6\n    // Undefined\n    SIMPLE_UNDEFINED, // 0xf7\n    // (simple value, one byte follows)\n    SIMPLE_BYTE, // 0xf8\n    // Half-Precision Float (two-byte IEEE 754)\n    SIMPLE_FLOAT_HALF, // 0xf9\n    // Single-Precision Float (four-byte IEEE 754)\n    SIMPLE_FLOAT_SINGLE, // 0xfa\n    // Double-Precision Float (eight-byte IEEE 754)\n    SIMPLE_FLOAT_DOUBLE, // 0xfb\n    ERROR, // 0xfc\n    ERROR, // 0xfd\n    ERROR, // 0xfe\n    // \"break\" stop code\n    BREAK // 0xff\n  ]\n\n  // --\n\n  return {\n    parse: parse\n  }\n}\n","'use strict'\n\nconst { Buffer } = require('buffer')\nconst ieee754 = require('ieee754')\nconst Bignumber = require('bignumber.js').BigNumber\n\nconst parser = require('./decoder.asm')\nconst utils = require('./utils')\nconst c = require('./constants')\nconst Simple = require('./simple')\nconst Tagged = require('./tagged')\nconst { URL } = require('iso-url')\n\n/**\n * Transform binary cbor data into JavaScript objects.\n */\nclass Decoder {\n  /**\n   * @param {Object} [opts={}]\n   * @param {number} [opts.size=65536] - Size of the allocated heap.\n   */\n  constructor (opts) {\n    opts = opts || {}\n\n    if (!opts.size || opts.size < 0x10000) {\n      opts.size = 0x10000\n    } else {\n      // Ensure the size is a power of 2\n      opts.size = utils.nextPowerOf2(opts.size)\n    }\n\n    // Heap use to share the input with the parser\n    this._heap = new ArrayBuffer(opts.size)\n    this._heap8 = new Uint8Array(this._heap)\n    this._buffer = Buffer.from(this._heap)\n\n    this._reset()\n\n    // Known tags\n    this._knownTags = Object.assign({\n      0: (val) => new Date(val),\n      1: (val) => new Date(val * 1000),\n      2: (val) => utils.arrayBufferToBignumber(val),\n      3: (val) => c.NEG_ONE.minus(utils.arrayBufferToBignumber(val)),\n      4: (v) => {\n        // const v = new Uint8Array(val)\n        return c.TEN.pow(v[0]).times(v[1])\n      },\n      5: (v) => {\n        // const v = new Uint8Array(val)\n        return c.TWO.pow(v[0]).times(v[1])\n      },\n      32: (val) => new URL(val),\n      35: (val) => new RegExp(val)\n    }, opts.tags)\n\n    // Initialize asm based parser\n    this.parser = parser(global, {\n      // eslint-disable-next-line no-console\n      log: console.log.bind(console),\n      pushInt: this.pushInt.bind(this),\n      pushInt32: this.pushInt32.bind(this),\n      pushInt32Neg: this.pushInt32Neg.bind(this),\n      pushInt64: this.pushInt64.bind(this),\n      pushInt64Neg: this.pushInt64Neg.bind(this),\n      pushFloat: this.pushFloat.bind(this),\n      pushFloatSingle: this.pushFloatSingle.bind(this),\n      pushFloatDouble: this.pushFloatDouble.bind(this),\n      pushTrue: this.pushTrue.bind(this),\n      pushFalse: this.pushFalse.bind(this),\n      pushUndefined: this.pushUndefined.bind(this),\n      pushNull: this.pushNull.bind(this),\n      pushInfinity: this.pushInfinity.bind(this),\n      pushInfinityNeg: this.pushInfinityNeg.bind(this),\n      pushNaN: this.pushNaN.bind(this),\n      pushNaNNeg: this.pushNaNNeg.bind(this),\n      pushArrayStart: this.pushArrayStart.bind(this),\n      pushArrayStartFixed: this.pushArrayStartFixed.bind(this),\n      pushArrayStartFixed32: this.pushArrayStartFixed32.bind(this),\n      pushArrayStartFixed64: this.pushArrayStartFixed64.bind(this),\n      pushObjectStart: this.pushObjectStart.bind(this),\n      pushObjectStartFixed: this.pushObjectStartFixed.bind(this),\n      pushObjectStartFixed32: this.pushObjectStartFixed32.bind(this),\n      pushObjectStartFixed64: this.pushObjectStartFixed64.bind(this),\n      pushByteString: this.pushByteString.bind(this),\n      pushByteStringStart: this.pushByteStringStart.bind(this),\n      pushUtf8String: this.pushUtf8String.bind(this),\n      pushUtf8StringStart: this.pushUtf8StringStart.bind(this),\n      pushSimpleUnassigned: this.pushSimpleUnassigned.bind(this),\n      pushTagUnassigned: this.pushTagUnassigned.bind(this),\n      pushTagStart: this.pushTagStart.bind(this),\n      pushTagStart4: this.pushTagStart4.bind(this),\n      pushTagStart8: this.pushTagStart8.bind(this),\n      pushBreak: this.pushBreak.bind(this)\n    }, this._heap)\n  }\n\n  get _depth () {\n    return this._parents.length\n  }\n\n  get _currentParent () {\n    return this._parents[this._depth - 1]\n  }\n\n  get _ref () {\n    return this._currentParent.ref\n  }\n\n  // Finish the current parent\n  _closeParent () {\n    var p = this._parents.pop()\n\n    if (p.length > 0) {\n      throw new Error(`Missing ${p.length} elements`)\n    }\n\n    switch (p.type) {\n      case c.PARENT.TAG:\n        this._push(\n          this.createTag(p.ref[0], p.ref[1])\n        )\n        break\n      case c.PARENT.BYTE_STRING:\n        this._push(this.createByteString(p.ref, p.length))\n        break\n      case c.PARENT.UTF8_STRING:\n        this._push(this.createUtf8String(p.ref, p.length))\n        break\n      case c.PARENT.MAP:\n        if (p.values % 2 > 0) {\n          throw new Error('Odd number of elements in the map')\n        }\n        this._push(this.createMap(p.ref, p.length))\n        break\n      case c.PARENT.OBJECT:\n        if (p.values % 2 > 0) {\n          throw new Error('Odd number of elements in the map')\n        }\n        this._push(this.createObject(p.ref, p.length))\n        break\n      case c.PARENT.ARRAY:\n        this._push(this.createArray(p.ref, p.length))\n        break\n      default:\n        break\n    }\n\n    if (this._currentParent && this._currentParent.type === c.PARENT.TAG) {\n      this._dec()\n    }\n  }\n\n  // Reduce the expected length of the current parent by one\n  _dec () {\n    const p = this._currentParent\n    // The current parent does not know the epxected child length\n\n    if (p.length < 0) {\n      return\n    }\n\n    p.length--\n\n    // All children were seen, we can close the current parent\n    if (p.length === 0) {\n      this._closeParent()\n    }\n  }\n\n  // Push any value to the current parent\n  _push (val, hasChildren) {\n    const p = this._currentParent\n    p.values++\n\n    switch (p.type) {\n      case c.PARENT.ARRAY:\n      case c.PARENT.BYTE_STRING:\n      case c.PARENT.UTF8_STRING:\n        if (p.length > -1) {\n          this._ref[this._ref.length - p.length] = val\n        } else {\n          this._ref.push(val)\n        }\n        this._dec()\n        break\n      case c.PARENT.OBJECT:\n        if (p.tmpKey != null) {\n          this._ref[p.tmpKey] = val\n          p.tmpKey = null\n          this._dec()\n        } else {\n          p.tmpKey = val\n\n          if (typeof p.tmpKey !== 'string') {\n            // too bad, convert to a Map\n            p.type = c.PARENT.MAP\n            p.ref = utils.buildMap(p.ref)\n          }\n        }\n        break\n      case c.PARENT.MAP:\n        if (p.tmpKey != null) {\n          this._ref.set(p.tmpKey, val)\n          p.tmpKey = null\n          this._dec()\n        } else {\n          p.tmpKey = val\n        }\n        break\n      case c.PARENT.TAG:\n        this._ref.push(val)\n        if (!hasChildren) {\n          this._dec()\n        }\n        break\n      default:\n        throw new Error('Unknown parent type')\n    }\n  }\n\n  // Create a new parent in the parents list\n  _createParent (obj, type, len) {\n    this._parents[this._depth] = {\n      type: type,\n      length: len,\n      ref: obj,\n      values: 0,\n      tmpKey: null\n    }\n  }\n\n  // Reset all state back to the beginning, also used for initiatlization\n  _reset () {\n    this._res = []\n    this._parents = [{\n      type: c.PARENT.ARRAY,\n      length: -1,\n      ref: this._res,\n      values: 0,\n      tmpKey: null\n    }]\n  }\n\n  // -- Interface to customize deoding behaviour\n  createTag (tagNumber, value) {\n    const typ = this._knownTags[tagNumber]\n\n    if (!typ) {\n      return new Tagged(tagNumber, value)\n    }\n\n    return typ(value)\n  }\n\n  createMap (obj, len) {\n    return obj\n  }\n\n  createObject (obj, len) {\n    return obj\n  }\n\n  createArray (arr, len) {\n    return arr\n  }\n\n  createByteString (raw, len) {\n    return Buffer.concat(raw)\n  }\n\n  createByteStringFromHeap (start, end) {\n    if (start === end) {\n      return Buffer.alloc(0)\n    }\n\n    return Buffer.from(this._heap.slice(start, end))\n  }\n\n  createInt (val) {\n    return val\n  }\n\n  createInt32 (f, g) {\n    return utils.buildInt32(f, g)\n  }\n\n  createInt64 (f1, f2, g1, g2) {\n    return utils.buildInt64(f1, f2, g1, g2)\n  }\n\n  createFloat (val) {\n    return val\n  }\n\n  createFloatSingle (a, b, c, d) {\n    return ieee754.read([a, b, c, d], 0, false, 23, 4)\n  }\n\n  createFloatDouble (a, b, c, d, e, f, g, h) {\n    return ieee754.read([a, b, c, d, e, f, g, h], 0, false, 52, 8)\n  }\n\n  createInt32Neg (f, g) {\n    return -1 - utils.buildInt32(f, g)\n  }\n\n  createInt64Neg (f1, f2, g1, g2) {\n    const f = utils.buildInt32(f1, f2)\n    const g = utils.buildInt32(g1, g2)\n\n    if (f > c.MAX_SAFE_HIGH) {\n      return c.NEG_ONE.minus(new Bignumber(f).times(c.SHIFT32).plus(g))\n    }\n\n    return -1 - ((f * c.SHIFT32) + g)\n  }\n\n  createTrue () {\n    return true\n  }\n\n  createFalse () {\n    return false\n  }\n\n  createNull () {\n    return null\n  }\n\n  createUndefined () {\n    return undefined\n  }\n\n  createInfinity () {\n    return Infinity\n  }\n\n  createInfinityNeg () {\n    return -Infinity\n  }\n\n  createNaN () {\n    return NaN\n  }\n\n  createNaNNeg () {\n    return -NaN\n  }\n\n  createUtf8String (raw, len) {\n    return raw.join('')\n  }\n\n  createUtf8StringFromHeap (start, end) {\n    if (start === end) {\n      return ''\n    }\n\n    return this._buffer.toString('utf8', start, end)\n  }\n\n  createSimpleUnassigned (val) {\n    return new Simple(val)\n  }\n\n  // -- Interface for decoder.asm.js\n\n  pushInt (val) {\n    this._push(this.createInt(val))\n  }\n\n  pushInt32 (f, g) {\n    this._push(this.createInt32(f, g))\n  }\n\n  pushInt64 (f1, f2, g1, g2) {\n    this._push(this.createInt64(f1, f2, g1, g2))\n  }\n\n  pushFloat (val) {\n    this._push(this.createFloat(val))\n  }\n\n  pushFloatSingle (a, b, c, d) {\n    this._push(this.createFloatSingle(a, b, c, d))\n  }\n\n  pushFloatDouble (a, b, c, d, e, f, g, h) {\n    this._push(this.createFloatDouble(a, b, c, d, e, f, g, h))\n  }\n\n  pushInt32Neg (f, g) {\n    this._push(this.createInt32Neg(f, g))\n  }\n\n  pushInt64Neg (f1, f2, g1, g2) {\n    this._push(this.createInt64Neg(f1, f2, g1, g2))\n  }\n\n  pushTrue () {\n    this._push(this.createTrue())\n  }\n\n  pushFalse () {\n    this._push(this.createFalse())\n  }\n\n  pushNull () {\n    this._push(this.createNull())\n  }\n\n  pushUndefined () {\n    this._push(this.createUndefined())\n  }\n\n  pushInfinity () {\n    this._push(this.createInfinity())\n  }\n\n  pushInfinityNeg () {\n    this._push(this.createInfinityNeg())\n  }\n\n  pushNaN () {\n    this._push(this.createNaN())\n  }\n\n  pushNaNNeg () {\n    this._push(this.createNaNNeg())\n  }\n\n  pushArrayStart () {\n    this._createParent([], c.PARENT.ARRAY, -1)\n  }\n\n  pushArrayStartFixed (len) {\n    this._createArrayStartFixed(len)\n  }\n\n  pushArrayStartFixed32 (len1, len2) {\n    const len = utils.buildInt32(len1, len2)\n    this._createArrayStartFixed(len)\n  }\n\n  pushArrayStartFixed64 (len1, len2, len3, len4) {\n    const len = utils.buildInt64(len1, len2, len3, len4)\n    this._createArrayStartFixed(len)\n  }\n\n  pushObjectStart () {\n    this._createObjectStartFixed(-1)\n  }\n\n  pushObjectStartFixed (len) {\n    this._createObjectStartFixed(len)\n  }\n\n  pushObjectStartFixed32 (len1, len2) {\n    const len = utils.buildInt32(len1, len2)\n    this._createObjectStartFixed(len)\n  }\n\n  pushObjectStartFixed64 (len1, len2, len3, len4) {\n    const len = utils.buildInt64(len1, len2, len3, len4)\n    this._createObjectStartFixed(len)\n  }\n\n  pushByteStringStart () {\n    this._parents[this._depth] = {\n      type: c.PARENT.BYTE_STRING,\n      length: -1,\n      ref: [],\n      values: 0,\n      tmpKey: null\n    }\n  }\n\n  pushByteString (start, end) {\n    this._push(this.createByteStringFromHeap(start, end))\n  }\n\n  pushUtf8StringStart () {\n    this._parents[this._depth] = {\n      type: c.PARENT.UTF8_STRING,\n      length: -1,\n      ref: [],\n      values: 0,\n      tmpKey: null\n    }\n  }\n\n  pushUtf8String (start, end) {\n    this._push(this.createUtf8StringFromHeap(start, end))\n  }\n\n  pushSimpleUnassigned (val) {\n    this._push(this.createSimpleUnassigned(val))\n  }\n\n  pushTagStart (tag) {\n    this._parents[this._depth] = {\n      type: c.PARENT.TAG,\n      length: 1,\n      ref: [tag]\n    }\n  }\n\n  pushTagStart4 (f, g) {\n    this.pushTagStart(utils.buildInt32(f, g))\n  }\n\n  pushTagStart8 (f1, f2, g1, g2) {\n    this.pushTagStart(utils.buildInt64(f1, f2, g1, g2))\n  }\n\n  pushTagUnassigned (tagNumber) {\n    this._push(this.createTag(tagNumber))\n  }\n\n  pushBreak () {\n    if (this._currentParent.length > -1) {\n      throw new Error('Unexpected break')\n    }\n\n    this._closeParent()\n  }\n\n  _createObjectStartFixed (len) {\n    if (len === 0) {\n      this._push(this.createObject({}))\n      return\n    }\n\n    this._createParent({}, c.PARENT.OBJECT, len)\n  }\n\n  _createArrayStartFixed (len) {\n    if (len === 0) {\n      this._push(this.createArray([]))\n      return\n    }\n\n    this._createParent(new Array(len), c.PARENT.ARRAY, len)\n  }\n\n  _decode (input) {\n    if (input.byteLength === 0) {\n      throw new Error('Input too short')\n    }\n\n    this._reset()\n    this._heap8.set(input)\n    const code = this.parser.parse(input.byteLength)\n\n    if (this._depth > 1) {\n      while (this._currentParent.length === 0) {\n        this._closeParent()\n      }\n      if (this._depth > 1) {\n        throw new Error('Undeterminated nesting')\n      }\n    }\n\n    if (code > 0) {\n      throw new Error('Failed to parse')\n    }\n\n    if (this._res.length === 0) {\n      throw new Error('No valid result')\n    }\n  }\n\n  // -- Public Interface\n\n  decodeFirst (input) {\n    this._decode(input)\n\n    return this._res[0]\n  }\n\n  decodeAll (input) {\n    this._decode(input)\n\n    return this._res\n  }\n\n  /**\n   * Decode the first cbor object.\n   *\n   * @param {Buffer|string} input\n   * @param {string} [enc='hex'] - Encoding used if a string is passed.\n   * @returns {*}\n   */\n  static decode (input, enc) {\n    if (typeof input === 'string') {\n      input = Buffer.from(input, enc || 'hex')\n    }\n\n    const dec = new Decoder({ size: input.length })\n    return dec.decodeFirst(input)\n  }\n\n  /**\n   * Decode all cbor objects.\n   *\n   * @param {Buffer|string} input\n   * @param {string} [enc='hex'] - Encoding used if a string is passed.\n   * @returns {Array<*>}\n   */\n  static decodeAll (input, enc) {\n    if (typeof input === 'string') {\n      input = Buffer.from(input, enc || 'hex')\n    }\n\n    const dec = new Decoder({ size: input.length })\n    return dec.decodeAll(input)\n  }\n}\n\nDecoder.decodeFirst = Decoder.decode\n\nmodule.exports = Decoder\n","'use strict'\n\nconst { Buffer } = require('buffer')\nconst Decoder = require('./decoder')\nconst utils = require('./utils')\n\n/**\n * Output the diagnostic format from a stream of CBOR bytes.\n *\n */\nclass Diagnose extends Decoder {\n  createTag (tagNumber, value) {\n    return `${tagNumber}(${value})`\n  }\n\n  createInt (val) {\n    return super.createInt(val).toString()\n  }\n\n  createInt32 (f, g) {\n    return super.createInt32(f, g).toString()\n  }\n\n  createInt64 (f1, f2, g1, g2) {\n    return super.createInt64(f1, f2, g1, g2).toString()\n  }\n\n  createInt32Neg (f, g) {\n    return super.createInt32Neg(f, g).toString()\n  }\n\n  createInt64Neg (f1, f2, g1, g2) {\n    return super.createInt64Neg(f1, f2, g1, g2).toString()\n  }\n\n  createTrue () {\n    return 'true'\n  }\n\n  createFalse () {\n    return 'false'\n  }\n\n  createFloat (val) {\n    const fl = super.createFloat(val)\n    if (utils.isNegativeZero(val)) {\n      return '-0_1'\n    }\n\n    return `${fl}_1`\n  }\n\n  createFloatSingle (a, b, c, d) {\n    const fl = super.createFloatSingle(a, b, c, d)\n    return `${fl}_2`\n  }\n\n  createFloatDouble (a, b, c, d, e, f, g, h) {\n    const fl = super.createFloatDouble(a, b, c, d, e, f, g, h)\n    return `${fl}_3`\n  }\n\n  createByteString (raw, len) {\n    const val = raw.join(', ')\n\n    if (len === -1) {\n      return `(_ ${val})`\n    }\n    return `h'${val}`\n  }\n\n  createByteStringFromHeap (start, end) {\n    const val = (Buffer.from(\n      super.createByteStringFromHeap(start, end)\n    )).toString('hex')\n\n    return `h'${val}'`\n  }\n\n  createInfinity () {\n    return 'Infinity_1'\n  }\n\n  createInfinityNeg () {\n    return '-Infinity_1'\n  }\n\n  createNaN () {\n    return 'NaN_1'\n  }\n\n  createNaNNeg () {\n    return '-NaN_1'\n  }\n\n  createNull () {\n    return 'null'\n  }\n\n  createUndefined () {\n    return 'undefined'\n  }\n\n  createSimpleUnassigned (val) {\n    return `simple(${val})`\n  }\n\n  createArray (arr, len) {\n    const val = super.createArray(arr, len)\n\n    if (len === -1) {\n      // indefinite\n      return `[_ ${val.join(', ')}]`\n    }\n\n    return `[${val.join(', ')}]`\n  }\n\n  createMap (map, len) {\n    const val = super.createMap(map)\n    const list = Array.from(val.keys())\n      .reduce(collectObject(val), '')\n\n    if (len === -1) {\n      return `{_ ${list}}`\n    }\n\n    return `{${list}}`\n  }\n\n  createObject (obj, len) {\n    const val = super.createObject(obj)\n    const map = Object.keys(val)\n      .reduce(collectObject(val), '')\n\n    if (len === -1) {\n      return `{_ ${map}}`\n    }\n\n    return `{${map}}`\n  }\n\n  createUtf8String (raw, len) {\n    const val = raw.join(', ')\n\n    if (len === -1) {\n      return `(_ ${val})`\n    }\n\n    return `\"${val}\"`\n  }\n\n  createUtf8StringFromHeap (start, end) {\n    const val = (Buffer.from(\n      super.createUtf8StringFromHeap(start, end)\n    )).toString('utf8')\n\n    return `\"${val}\"`\n  }\n\n  static diagnose (input, enc) {\n    if (typeof input === 'string') {\n      input = Buffer.from(input, enc || 'hex')\n    }\n\n    const dec = new Diagnose()\n    return dec.decodeFirst(input)\n  }\n}\n\nmodule.exports = Diagnose\n\nfunction collectObject (val) {\n  return (acc, key) => {\n    if (acc) {\n      return `${acc}, ${key}: ${val[key]}`\n    }\n    return `${key}: ${val[key]}`\n  }\n}\n","'use strict'\n\nconst { Buffer } = require('buffer')\nconst { URL } = require('iso-url')\nconst Bignumber = require('bignumber.js').BigNumber\n\nconst utils = require('./utils')\nconst constants = require('./constants')\nconst MT = constants.MT\nconst NUMBYTES = constants.NUMBYTES\nconst SHIFT32 = constants.SHIFT32\nconst SYMS = constants.SYMS\nconst TAG = constants.TAG\nconst HALF = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.TWO\nconst FLOAT = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.FOUR\nconst DOUBLE = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.EIGHT\nconst TRUE = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.TRUE\nconst FALSE = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.FALSE\nconst UNDEFINED = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.UNDEFINED\nconst NULL = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.NULL\n\nconst MAXINT_BN = new Bignumber('0x20000000000000')\nconst BUF_NAN = Buffer.from('f97e00', 'hex')\nconst BUF_INF_NEG = Buffer.from('f9fc00', 'hex')\nconst BUF_INF_POS = Buffer.from('f97c00', 'hex')\n\nfunction toType (obj) {\n  // [object Type]\n  // --------8---1\n  return ({}).toString.call(obj).slice(8, -1)\n}\n\n/**\n * Transform JavaScript values into CBOR bytes\n *\n */\nclass Encoder {\n  /**\n   * @param {Object} [options={}]\n   * @param {function(Buffer)} options.stream\n   */\n  constructor (options) {\n    options = options || {}\n\n    this.streaming = typeof options.stream === 'function'\n    this.onData = options.stream\n\n    this.semanticTypes = [\n      [URL, this._pushUrl],\n      [Bignumber, this._pushBigNumber]\n    ]\n\n    const addTypes = options.genTypes || []\n    const len = addTypes.length\n    for (let i = 0; i < len; i++) {\n      this.addSemanticType(\n        addTypes[i][0],\n        addTypes[i][1]\n      )\n    }\n\n    this._reset()\n  }\n\n  addSemanticType (type, fun) {\n    const len = this.semanticTypes.length\n    for (let i = 0; i < len; i++) {\n      const typ = this.semanticTypes[i][0]\n      if (typ === type) {\n        const old = this.semanticTypes[i][1]\n        this.semanticTypes[i][1] = fun\n        return old\n      }\n    }\n    this.semanticTypes.push([type, fun])\n    return null\n  }\n\n  push (val) {\n    if (!val) {\n      return true\n    }\n\n    this.result[this.offset] = val\n    this.resultMethod[this.offset] = 0\n    this.resultLength[this.offset] = val.length\n    this.offset++\n\n    if (this.streaming) {\n      this.onData(this.finalize())\n    }\n\n    return true\n  }\n\n  pushWrite (val, method, len) {\n    this.result[this.offset] = val\n    this.resultMethod[this.offset] = method\n    this.resultLength[this.offset] = len\n    this.offset++\n\n    if (this.streaming) {\n      this.onData(this.finalize())\n    }\n\n    return true\n  }\n\n  _pushUInt8 (val) {\n    return this.pushWrite(val, 1, 1)\n  }\n\n  _pushUInt16BE (val) {\n    return this.pushWrite(val, 2, 2)\n  }\n\n  _pushUInt32BE (val) {\n    return this.pushWrite(val, 3, 4)\n  }\n\n  _pushDoubleBE (val) {\n    return this.pushWrite(val, 4, 8)\n  }\n\n  _pushNaN () {\n    return this.push(BUF_NAN)\n  }\n\n  _pushInfinity (obj) {\n    const half = (obj < 0) ? BUF_INF_NEG : BUF_INF_POS\n    return this.push(half)\n  }\n\n  _pushFloat (obj) {\n    const b2 = Buffer.allocUnsafe(2)\n\n    if (utils.writeHalf(b2, obj)) {\n      if (utils.parseHalf(b2) === obj) {\n        return this._pushUInt8(HALF) && this.push(b2)\n      }\n    }\n\n    const b4 = Buffer.allocUnsafe(4)\n    b4.writeFloatBE(obj, 0)\n    if (b4.readFloatBE(0) === obj) {\n      return this._pushUInt8(FLOAT) && this.push(b4)\n    }\n\n    return this._pushUInt8(DOUBLE) && this._pushDoubleBE(obj)\n  }\n\n  _pushInt (obj, mt, orig) {\n    const m = mt << 5\n    if (obj < 24) {\n      return this._pushUInt8(m | obj)\n    }\n\n    if (obj <= 0xff) {\n      return this._pushUInt8(m | NUMBYTES.ONE) && this._pushUInt8(obj)\n    }\n\n    if (obj <= 0xffff) {\n      return this._pushUInt8(m | NUMBYTES.TWO) && this._pushUInt16BE(obj)\n    }\n\n    if (obj <= 0xffffffff) {\n      return this._pushUInt8(m | NUMBYTES.FOUR) && this._pushUInt32BE(obj)\n    }\n\n    if (obj <= Number.MAX_SAFE_INTEGER) {\n      return this._pushUInt8(m | NUMBYTES.EIGHT) &&\n        this._pushUInt32BE(Math.floor(obj / SHIFT32)) &&\n        this._pushUInt32BE(obj % SHIFT32)\n    }\n\n    if (mt === MT.NEG_INT) {\n      return this._pushFloat(orig)\n    }\n\n    return this._pushFloat(obj)\n  }\n\n  _pushIntNum (obj) {\n    if (obj < 0) {\n      return this._pushInt(-obj - 1, MT.NEG_INT, obj)\n    } else {\n      return this._pushInt(obj, MT.POS_INT)\n    }\n  }\n\n  _pushNumber (obj) {\n    switch (false) {\n      case (obj === obj): // eslint-disable-line\n        return this._pushNaN(obj)\n      case isFinite(obj):\n        return this._pushInfinity(obj)\n      case ((obj % 1) !== 0):\n        return this._pushIntNum(obj)\n      default:\n        return this._pushFloat(obj)\n    }\n  }\n\n  _pushString (obj) {\n    const len = Buffer.byteLength(obj, 'utf8')\n    return this._pushInt(len, MT.UTF8_STRING) && this.pushWrite(obj, 5, len)\n  }\n\n  _pushBoolean (obj) {\n    return this._pushUInt8(obj ? TRUE : FALSE)\n  }\n\n  _pushUndefined (obj) {\n    return this._pushUInt8(UNDEFINED)\n  }\n\n  _pushArray (gen, obj) {\n    const len = obj.length\n    if (!gen._pushInt(len, MT.ARRAY)) {\n      return false\n    }\n    for (let j = 0; j < len; j++) {\n      if (!gen.pushAny(obj[j])) {\n        return false\n      }\n    }\n    return true\n  }\n\n  _pushTag (tag) {\n    return this._pushInt(tag, MT.TAG)\n  }\n\n  _pushDate (gen, obj) {\n    // Round date, to get seconds since 1970-01-01 00:00:00 as defined in\n    // Sec. 2.4.1 and get a possibly more compact encoding. Note that it is\n    // still allowed to encode fractions of seconds which can be achieved by\n    // changing overwriting the encode function for Date objects.\n    return gen._pushTag(TAG.DATE_EPOCH) && gen.pushAny(Math.round(obj / 1000))\n  }\n\n  _pushBuffer (gen, obj) {\n    return gen._pushInt(obj.length, MT.BYTE_STRING) && gen.push(obj)\n  }\n\n  _pushNoFilter (gen, obj) {\n    return gen._pushBuffer(gen, obj.slice())\n  }\n\n  _pushRegexp (gen, obj) {\n    return gen._pushTag(TAG.REGEXP) && gen.pushAny(obj.source)\n  }\n\n  _pushSet (gen, obj) {\n    if (!gen._pushInt(obj.size, MT.ARRAY)) {\n      return false\n    }\n    for (const x of obj) {\n      if (!gen.pushAny(x)) {\n        return false\n      }\n    }\n    return true\n  }\n\n  _pushUrl (gen, obj) {\n    return gen._pushTag(TAG.URI) && gen.pushAny(obj.format())\n  }\n\n  _pushBigint (obj) {\n    let tag = TAG.POS_BIGINT\n    if (obj.isNegative()) {\n      obj = obj.negated().minus(1)\n      tag = TAG.NEG_BIGINT\n    }\n    let str = obj.toString(16)\n    if (str.length % 2) {\n      str = '0' + str\n    }\n    const buf = Buffer.from(str, 'hex')\n    return this._pushTag(tag) && this._pushBuffer(this, buf)\n  }\n\n  _pushBigNumber (gen, obj) {\n    if (obj.isNaN()) {\n      return gen._pushNaN()\n    }\n    if (!obj.isFinite()) {\n      return gen._pushInfinity(obj.isNegative() ? -Infinity : Infinity)\n    }\n    if (obj.isInteger()) {\n      return gen._pushBigint(obj)\n    }\n    if (!(gen._pushTag(TAG.DECIMAL_FRAC) &&\n      gen._pushInt(2, MT.ARRAY))) {\n      return false\n    }\n\n    const dec = obj.decimalPlaces()\n    const slide = obj.multipliedBy(new Bignumber(10).pow(dec))\n    if (!gen._pushIntNum(-dec)) {\n      return false\n    }\n    if (slide.abs().isLessThan(MAXINT_BN)) {\n      return gen._pushIntNum(slide.toNumber())\n    } else {\n      return gen._pushBigint(slide)\n    }\n  }\n\n  _pushMap (gen, obj) {\n    if (!gen._pushInt(obj.size, MT.MAP)) {\n      return false\n    }\n\n    return this._pushRawMap(\n      obj.size,\n      Array.from(obj)\n    )\n  }\n\n  _pushObject (obj) {\n    if (!obj) {\n      return this._pushUInt8(NULL)\n    }\n\n    var len = this.semanticTypes.length\n    for (var i = 0; i < len; i++) {\n      if (obj instanceof this.semanticTypes[i][0]) {\n        return this.semanticTypes[i][1].call(obj, this, obj)\n      }\n    }\n\n    var f = obj.encodeCBOR\n    if (typeof f === 'function') {\n      return f.call(obj, this)\n    }\n\n    var keys = Object.keys(obj)\n    var keyLength = keys.length\n    if (!this._pushInt(keyLength, MT.MAP)) {\n      return false\n    }\n\n    return this._pushRawMap(\n      keyLength,\n      keys.map((k) => [k, obj[k]])\n    )\n  }\n\n  _pushRawMap (len, map) {\n    // Sort keys for canoncialization\n    // 1. encode key\n    // 2. shorter key comes before longer key\n    // 3. same length keys are sorted with lower\n    //    byte value before higher\n\n    map = map.map(function (a) {\n      a[0] = Encoder.encode(a[0])\n      return a\n    }).sort(utils.keySorter)\n\n    for (var j = 0; j < len; j++) {\n      if (!this.push(map[j][0])) {\n        return false\n      }\n\n      if (!this.pushAny(map[j][1])) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  /**\n   * Alias for `.pushAny`\n   *\n   * @param {*} obj\n   * @returns {boolean} true on success\n   */\n  write (obj) {\n    return this.pushAny(obj)\n  }\n\n  /**\n   * Push any supported type onto the encoded stream\n   *\n   * @param {any} obj\n   * @returns {boolean} true on success\n   */\n  pushAny (obj) {\n    var typ = toType(obj)\n\n    switch (typ) {\n      case 'Number':\n        return this._pushNumber(obj)\n      case 'String':\n        return this._pushString(obj)\n      case 'Boolean':\n        return this._pushBoolean(obj)\n      case 'Object':\n        return this._pushObject(obj)\n      case 'Array':\n        return this._pushArray(this, obj)\n      case 'Uint8Array':\n        return this._pushBuffer(this, Buffer.isBuffer(obj) ? obj : Buffer.from(obj))\n      case 'Null':\n        return this._pushUInt8(NULL)\n      case 'Undefined':\n        return this._pushUndefined(obj)\n      case 'Map':\n        return this._pushMap(this, obj)\n      case 'Set':\n        return this._pushSet(this, obj)\n      case 'URL':\n        return this._pushUrl(this, obj)\n      case 'BigNumber':\n        return this._pushBigNumber(this, obj)\n      case 'Date':\n        return this._pushDate(this, obj)\n      case 'RegExp':\n        return this._pushRegexp(this, obj)\n      case 'Symbol':\n        switch (obj) {\n          case SYMS.NULL:\n            return this._pushObject(null)\n          case SYMS.UNDEFINED:\n            return this._pushUndefined(undefined)\n          // TODO: Add pluggable support for other symbols\n          default:\n            throw new Error('Unknown symbol: ' + obj.toString())\n        }\n      default:\n        throw new Error('Unknown type: ' + typeof obj + ', ' + (obj ? obj.toString() : ''))\n    }\n  }\n\n  finalize () {\n    if (this.offset === 0) {\n      return null\n    }\n\n    var result = this.result\n    var resultLength = this.resultLength\n    var resultMethod = this.resultMethod\n    var offset = this.offset\n\n    // Determine the size of the buffer\n    var size = 0\n    var i = 0\n\n    for (; i < offset; i++) {\n      size += resultLength[i]\n    }\n\n    var res = Buffer.allocUnsafe(size)\n    var index = 0\n    var length = 0\n\n    // Write the content into the result buffer\n    for (i = 0; i < offset; i++) {\n      length = resultLength[i]\n\n      switch (resultMethod[i]) {\n        case 0:\n          result[i].copy(res, index)\n          break\n        case 1:\n          res.writeUInt8(result[i], index, true)\n          break\n        case 2:\n          res.writeUInt16BE(result[i], index, true)\n          break\n        case 3:\n          res.writeUInt32BE(result[i], index, true)\n          break\n        case 4:\n          res.writeDoubleBE(result[i], index, true)\n          break\n        case 5:\n          res.write(result[i], index, length, 'utf8')\n          break\n        default:\n          throw new Error('unkown method')\n      }\n\n      index += length\n    }\n\n    var tmp = res\n\n    this._reset()\n\n    return tmp\n  }\n\n  _reset () {\n    this.result = []\n    this.resultMethod = []\n    this.resultLength = []\n    this.offset = 0\n  }\n\n  /**\n   * Encode the given value\n   * @param {*} o\n   * @returns {Buffer}\n   */\n  static encode (o) {\n    const enc = new Encoder()\n    const ret = enc.pushAny(o)\n    if (!ret) {\n      throw new Error('Failed to encode input')\n    }\n\n    return enc.finalize()\n  }\n}\n\nmodule.exports = Encoder\n","'use strict'\n\n// exports.Commented = require('./commented')\nexports.Diagnose = require('./diagnose')\nexports.Decoder = require('./decoder')\nexports.Encoder = require('./encoder')\nexports.Simple = require('./simple')\nexports.Tagged = require('./tagged')\n\n// exports.comment = exports.Commented.comment\nexports.decodeAll = exports.Decoder.decodeAll\nexports.decodeFirst = exports.Decoder.decodeFirst\nexports.diagnose = exports.Diagnose.diagnose\nexports.encode = exports.Encoder.encode\nexports.decode = exports.Decoder.decode\n\nexports.leveldb = {\n  decode: exports.Decoder.decodeAll,\n  encode: exports.Encoder.encode,\n  buffer: true,\n  name: 'cbor'\n}\n","'use strict'\n\nconst constants = require('./constants')\nconst MT = constants.MT\nconst SIMPLE = constants.SIMPLE\nconst SYMS = constants.SYMS\n\n/**\n * A CBOR Simple Value that does not map onto a known constant.\n */\nclass Simple {\n  /**\n   * Creates an instance of Simple.\n   *\n   * @param {integer} value - the simple value's integer value\n   */\n  constructor (value) {\n    if (typeof value !== 'number') {\n      throw new Error('Invalid Simple type: ' + (typeof value))\n    }\n    if ((value < 0) || (value > 255) || ((value | 0) !== value)) {\n      throw new Error('value must be a small positive integer: ' + value)\n    }\n    this.value = value\n  }\n\n  /**\n   * Debug string for simple value\n   *\n   * @returns {string} simple(value)\n   */\n  toString () {\n    return 'simple(' + this.value + ')'\n  }\n\n  /**\n   * Debug string for simple value\n   *\n   * @returns {string} simple(value)\n   */\n  inspect () {\n    return 'simple(' + this.value + ')'\n  }\n\n  /**\n   * Push the simple value onto the CBOR stream\n   *\n   * @param {cbor.Encoder} gen The generator to push onto\n   * @returns {number}\n   */\n  encodeCBOR (gen) {\n    return gen._pushInt(this.value, MT.SIMPLE_FLOAT)\n  }\n\n  /**\n   * Is the given object a Simple?\n   *\n   * @param {any} obj - object to test\n   * @returns {bool} - is it Simple?\n   */\n  static isSimple (obj) {\n    return obj instanceof Simple\n  }\n\n  /**\n   * Decode from the CBOR additional information into a JavaScript value.\n   * If the CBOR item has no parent, return a \"safe\" symbol instead of\n   * `null` or `undefined`, so that the value can be passed through a\n   * stream in object mode.\n   *\n   * @param {Number} val - the CBOR additional info to convert\n   * @param {bool} hasParent - Does the CBOR item have a parent?\n   * @returns {(null|undefined|Boolean|Symbol)} - the decoded value\n   */\n  static decode (val, hasParent) {\n    if (hasParent == null) {\n      hasParent = true\n    }\n    switch (val) {\n      case SIMPLE.FALSE:\n        return false\n      case SIMPLE.TRUE:\n        return true\n      case SIMPLE.NULL:\n        if (hasParent) {\n          return null\n        } else {\n          return SYMS.NULL\n        }\n      case SIMPLE.UNDEFINED:\n        if (hasParent) {\n          return undefined\n        } else {\n          return SYMS.UNDEFINED\n        }\n      case -1:\n        if (!hasParent) {\n          throw new Error('Invalid BREAK')\n        }\n        return SYMS.BREAK\n      default:\n        return new Simple(val)\n    }\n  }\n}\n\nmodule.exports = Simple\n","'use strict'\n\n/**\n * A CBOR tagged item, where the tag does not have semantics specified at the\n * moment, or those semantics threw an error during parsing. Typically this will\n * be an extension point you're not yet expecting.\n */\nclass Tagged {\n  /**\n   * Creates an instance of Tagged.\n   *\n   * @param {Number} tag - the number of the tag\n   * @param {any} value - the value inside the tag\n   * @param {Error} err - the error that was thrown parsing the tag, or null\n   */\n  constructor (tag, value, err) {\n    this.tag = tag\n    this.value = value\n    this.err = err\n    if (typeof this.tag !== 'number') {\n      throw new Error('Invalid tag type (' + (typeof this.tag) + ')')\n    }\n    if ((this.tag < 0) || ((this.tag | 0) !== this.tag)) {\n      throw new Error('Tag must be a positive integer: ' + this.tag)\n    }\n  }\n\n  /**\n   * Convert to a String\n   *\n   * @returns {String} string of the form '1(2)'\n   */\n  toString () {\n    return `${this.tag}(${JSON.stringify(this.value)})`\n  }\n\n  /**\n   * Push the simple value onto the CBOR stream\n   *\n   * @param {cbor.Encoder} gen The generator to push onto\n   * @returns {number}\n   */\n  encodeCBOR (gen) {\n    gen._pushTag(this.tag)\n    return gen.pushAny(this.value)\n  }\n\n  /**\n   * If we have a converter for this type, do the conversion.  Some converters\n   * are built-in.  Additional ones can be passed in.  If you want to remove\n   * a built-in converter, pass a converter in whose value is 'null' instead\n   * of a function.\n   *\n   * @param {Object} converters - keys in the object are a tag number, the value\n   *   is a function that takes the decoded CBOR and returns a JavaScript value\n   *   of the appropriate type.  Throw an exception in the function on errors.\n   * @returns {any} - the converted item\n   */\n  convert (converters) {\n    var er, f\n    f = converters != null ? converters[this.tag] : undefined\n    if (typeof f !== 'function') {\n      f = Tagged['_tag' + this.tag]\n      if (typeof f !== 'function') {\n        return this\n      }\n    }\n    try {\n      return f.call(Tagged, this.value)\n    } catch (error) {\n      er = error\n      this.err = er\n      return this\n    }\n  }\n}\n\nmodule.exports = Tagged\n","'use strict'\n\nconst { Buffer } = require('buffer')\nconst Bignumber = require('bignumber.js').BigNumber\n\nconst constants = require('./constants')\nconst SHIFT32 = constants.SHIFT32\nconst SHIFT16 = constants.SHIFT16\nconst MAX_SAFE_HIGH = 0x1fffff\n\nexports.parseHalf = function parseHalf (buf) {\n  var exp, mant, sign\n  sign = buf[0] & 0x80 ? -1 : 1\n  exp = (buf[0] & 0x7C) >> 2\n  mant = ((buf[0] & 0x03) << 8) | buf[1]\n  if (!exp) {\n    return sign * 5.9604644775390625e-8 * mant\n  } else if (exp === 0x1f) {\n    return sign * (mant ? 0 / 0 : 2e308)\n  } else {\n    return sign * Math.pow(2, exp - 25) * (1024 + mant)\n  }\n}\n\nfunction toHex (n) {\n  if (n < 16) {\n    return '0' + n.toString(16)\n  }\n\n  return n.toString(16)\n}\n\nexports.arrayBufferToBignumber = function (buf) {\n  const len = buf.byteLength\n  let res = ''\n  for (let i = 0; i < len; i++) {\n    res += toHex(buf[i])\n  }\n\n  return new Bignumber(res, 16)\n}\n\n// convert an Object into a Map\nexports.buildMap = (obj) => {\n  const res = new Map()\n  const keys = Object.keys(obj)\n  const length = keys.length\n  for (let i = 0; i < length; i++) {\n    res.set(keys[i], obj[keys[i]])\n  }\n  return res\n}\n\nexports.buildInt32 = (f, g) => {\n  return f * SHIFT16 + g\n}\n\nexports.buildInt64 = (f1, f2, g1, g2) => {\n  const f = exports.buildInt32(f1, f2)\n  const g = exports.buildInt32(g1, g2)\n\n  if (f > MAX_SAFE_HIGH) {\n    return new Bignumber(f).times(SHIFT32).plus(g)\n  } else {\n    return (f * SHIFT32) + g\n  }\n}\n\nexports.writeHalf = function writeHalf (buf, half) {\n  // assume 0, -0, NaN, Infinity, and -Infinity have already been caught\n\n  // HACK: everyone settle in.  This isn't going to be pretty.\n  // Translate cn-cbor's C code (from Carsten Borman):\n\n  // uint32_t be32;\n  // uint16_t be16, u16;\n  // union {\n  //   float f;\n  //   uint32_t u;\n  // } u32;\n  // u32.f = float_val;\n\n  const u32 = Buffer.allocUnsafe(4)\n  u32.writeFloatBE(half, 0)\n  const u = u32.readUInt32BE(0)\n\n  // if ((u32.u & 0x1FFF) == 0) { /* worth trying half */\n\n  // hildjj: If the lower 13 bits are 0, we won't lose anything in the conversion\n  if ((u & 0x1FFF) !== 0) {\n    return false\n  }\n\n  //   int s16 = (u32.u >> 16) & 0x8000;\n  //   int exp = (u32.u >> 23) & 0xff;\n  //   int mant = u32.u & 0x7fffff;\n\n  var s16 = (u >> 16) & 0x8000 // top bit is sign\n  const exp = (u >> 23) & 0xff // then 5 bits of exponent\n  const mant = u & 0x7fffff\n\n  //   if (exp == 0 && mant == 0)\n  //     ;              /* 0.0, -0.0 */\n\n  // hildjj: zeros already handled.  Assert if you don't believe me.\n\n  //   else if (exp >= 113 && exp <= 142) /* normalized */\n  //     s16 += ((exp - 112) << 10) + (mant >> 13);\n  if ((exp >= 113) && (exp <= 142)) {\n    s16 += ((exp - 112) << 10) + (mant >> 13)\n\n  //   else if (exp >= 103 && exp < 113) { /* denorm, exp16 = 0 */\n  //     if (mant & ((1 << (126 - exp)) - 1))\n  //       goto float32;         /* loss of precision */\n  //     s16 += ((mant + 0x800000) >> (126 - exp));\n  } else if ((exp >= 103) && (exp < 113)) {\n    if (mant & ((1 << (126 - exp)) - 1)) {\n      return false\n    }\n    s16 += ((mant + 0x800000) >> (126 - exp))\n\n    //   } else if (exp == 255 && mant == 0) { /* Inf */\n    //     s16 += 0x7c00;\n\n    // hildjj: Infinity already handled\n\n  //   } else\n  //     goto float32;           /* loss of range */\n  } else {\n    return false\n  }\n\n  //   ensure_writable(3);\n  //   u16 = s16;\n  //   be16 = hton16p((const uint8_t*)&u16);\n  buf.writeUInt16BE(s16, 0)\n  return true\n}\n\nexports.keySorter = function (a, b) {\n  var lenA = a[0].byteLength\n  var lenB = b[0].byteLength\n\n  if (lenA > lenB) {\n    return 1\n  }\n\n  if (lenB > lenA) {\n    return -1\n  }\n\n  return a[0].compare(b[0])\n}\n\n// Adapted from http://www.2ality.com/2012/03/signedzero.html\nexports.isNegativeZero = (x) => {\n  return x === 0 && (1 / x < 0)\n}\n\nexports.nextPowerOf2 = (n) => {\n  let count = 0\n  // First n in the below condition is for\n  // the case where n is 0\n  if (n && !(n & (n - 1))) {\n    return n\n  }\n\n  while (n !== 0) {\n    n >>= 1\n    count += 1\n  }\n\n  return 1 << count\n}\n","'use strict'\nconst Buffer = require('safe-buffer').Buffer\n\nmodule.exports = class BufferPipe {\n  /**\n   * Creates a new instance of a pipe\n   * @param {Buffer} buf - an optional buffer to start with\n   */\n  constructor (buf = Buffer.from([])) {\n    this.buffer = buf\n    this._bytesRead = 0\n    this._bytesWrote = 0\n  }\n\n  /**\n   * read `num` number of bytes from the pipe\n   * @param {Number} num\n   * @return {Buffer}\n   */\n  read (num) {\n    this._bytesRead += num\n    const data = this.buffer.slice(0, num)\n    this.buffer = this.buffer.slice(num)\n    return data\n  }\n\n  /**\n   * Wites a buffer to the pipe\n   * @param {Buffer} buf\n   */\n  write (buf) {\n    buf = Buffer.from(buf)\n    this._bytesWrote += buf.length\n    this.buffer = Buffer.concat([this.buffer, buf])\n  }\n\n  /**\n   * Whether or not there is more data to read from the buffer\n   * returns {Boolean}\n   */\n  get end () {\n    return !this.buffer.length\n  }\n\n  /**\n   * returns the number of bytes read from the stream\n   * @return {Integer}\n   */\n  get bytesRead () {\n    return this._bytesRead\n  }\n\n  /**\n   * returns the number of bytes wrote to the stream\n   * @return {Integer}\n   */\n  get bytesWrote () {\n    return this._bytesWrote\n  }\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               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 * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    const arr = new Uint8Array(1)\n    const proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  const buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\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  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  const valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  const b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\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(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(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 interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(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(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\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(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(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  const length = byteLength(string, encoding) | 0\n  let buf = createBuffer(length)\n\n  const actual = buf.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    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  const length = array.length < 0 ? 0 : checked(array.length) | 0\n  const buf = createBuffer(length)\n  for (let i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    const copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  let buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    const len = checked(obj.length) | 0\n    const buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.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 === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  let x = a.length\n  let y = b.length\n\n  for (let 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 (!Array.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  let 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  const buffer = Buffer.allocUnsafe(length)\n  let pos = 0\n  for (i = 0; i < list.length; ++i) {\n    let buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n        buf.copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\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 (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  const len = string.length\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  let 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        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) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  let 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 coercion 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// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  const i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  const len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (let i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  const len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (let 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  const len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (let 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  const length = this.length\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.toLocaleString = Buffer.prototype.toString\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  let str = ''\n  const max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\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  let x = thisEnd - thisStart\n  let y = end - start\n  const len = Math.min(x, y)\n\n  const thisCopy = this.slice(thisStart, thisEnd)\n  const targetCopy = target.slice(start, end)\n\n  for (let 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 (numberIsNaN(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 (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  let indexSize = 1\n  let arrLength = arr.length\n  let 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  let i\n  if (dir) {\n    let 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      let found = true\n      for (let 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  const 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  const strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  let i\n  for (i = 0; i < length; ++i) {\n    const parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(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 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  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  const 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  let 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      case 'latin1':\n      case 'binary':\n        return asciiWrite(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  const res = []\n\n  let i = start\n  while (i < end) {\n    const firstByte = buf[i]\n    let codePoint = null\n    let bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      let 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\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  const 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  let res = ''\n  let 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  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  const len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  let out = ''\n  for (let i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  const bytes = buf.slice(start, end)\n  let res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (let i = 0; i < bytes.length - 1; 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  const 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  const newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\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 =\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  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\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  let val = this[offset + --byteLength]\n  let mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\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 =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\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.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const lo = first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24\n\n  const hi = this[++offset] +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    last * 2 ** 24\n\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const hi = first * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  const lo = this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last\n\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\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  let val = this[offset]\n  let mul = 1\n  let 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  let i = byteLength\n  let mul = 1\n  let 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  offset = offset >>> 0\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  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\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  offset = offset >>> 0\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.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = this[offset + 4] +\n    this[offset + 5] * 2 ** 8 +\n    this[offset + 6] * 2 ** 16 +\n    (last << 24) // Overflow\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = (first << 24) + // Overflow\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last)\n})\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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 =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let mul = 1\n  let 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 =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let i = byteLength - 1\n  let 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 =\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  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\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  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\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  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\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  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset + 7] = lo\n  lo = lo >> 8\n  buf[offset + 6] = lo\n  lo = lo >> 8\n  buf[offset + 5] = lo\n  lo = lo >> 8\n  buf[offset + 4] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset + 3] = hi\n  hi = hi >> 8\n  buf[offset + 2] = hi\n  hi = hi >> 8\n  buf[offset + 1] = hi\n  hi = hi >> 8\n  buf[offset] = hi\n  return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = 0\n  let mul = 1\n  let 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    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  let 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 (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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\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  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\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  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\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  value = +value\n  offset = offset >>> 0\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  value = +value\n  offset = offset >>> 0\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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\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('Index out of range')\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  const len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\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 (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    if (val.length === 1) {\n      const code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\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  let i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    const bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    const len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n  errors[sym] = class NodeError extends Base {\n    constructor () {\n      super()\n\n      Object.defineProperty(this, 'message', {\n        value: getMessage.apply(this, arguments),\n        writable: true,\n        configurable: true\n      })\n\n      // Add the error code to the name to include it in the stack trace.\n      this.name = `${this.name} [${sym}]`\n      // Access the stack to generate the error message including the error code\n      // from the name.\n      this.stack // eslint-disable-line no-unused-expressions\n      // Reset the name to the actual name.\n      delete this.name\n    }\n\n    get code () {\n      return sym\n    }\n\n    set code (value) {\n      Object.defineProperty(this, 'code', {\n        configurable: true,\n        enumerable: true,\n        value,\n        writable: true\n      })\n    }\n\n    toString () {\n      return `${this.name} [${sym}]: ${this.message}`\n    }\n  }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n  function (name) {\n    if (name) {\n      return `${name} is outside of buffer bounds`\n    }\n\n    return 'Attempt to access memory outside buffer bounds'\n  }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n  function (name, actual) {\n    return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n  }, TypeError)\nE('ERR_OUT_OF_RANGE',\n  function (str, range, input) {\n    let msg = `The value of \"${str}\" is out of range.`\n    let received = input\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n      received = addNumericalSeparator(String(input))\n    } else if (typeof input === 'bigint') {\n      received = String(input)\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    }\n    msg += ` It must be ${range}. Received ${received}`\n    return msg\n  }, RangeError)\n\nfunction addNumericalSeparator (val) {\n  let res = ''\n  let i = val.length\n  const start = val[0] === '-' ? 1 : 0\n  for (; i >= start + 4; i -= 3) {\n    res = `_${val.slice(i - 3, i)}${res}`\n  }\n  return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n  validateNumber(offset, 'offset')\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n    boundsError(offset, buf.length - (byteLength + 1))\n  }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n  if (value > max || value < min) {\n    const n = typeof min === 'bigint' ? 'n' : ''\n    let range\n    if (byteLength > 3) {\n      if (min === 0 || min === BigInt(0)) {\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n      } else {\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n                `${(byteLength + 1) * 8 - 1}${n}`\n      }\n    } else {\n      range = `>= ${min}${n} and <= ${max}${n}`\n    }\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n  }\n  checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n  if (typeof value !== 'number') {\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n}\n\nfunction boundsError (value, length, type) {\n  if (Math.floor(value) !== value) {\n    validateNumber(value, type)\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n  }\n\n  if (length < 0) {\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n  }\n\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\n                                    value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().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 utf8ToBytes (string, units) {\n  units = units || Infinity\n  let codePoint\n  const length = string.length\n  let leadSurrogate = null\n  const bytes = []\n\n  for (let 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  const byteArray = []\n  for (let 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  let c, hi, lo\n  const byteArray = []\n  for (let 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  let i\n  for (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\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n  const alphabet = '0123456789abcdef'\n  const table = new Array(256)\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n  throw new Error('BigInt not supported')\n}\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","'use strict';\n\nconst {\n    URLWithLegacySupport,\n    format,\n    URLSearchParams,\n    defaultBase\n} = require('./src/url');\nconst relative = require('./src/relative');\n\nmodule.exports = {\n    URL: URLWithLegacySupport,\n    URLSearchParams,\n    format,\n    relative,\n    defaultBase\n};\n","'use strict';\n\nconst { URLWithLegacySupport, format } = require('./url');\n\nmodule.exports = (url, location = {}, protocolMap = {}, defaultProtocol) => {\n    let protocol = location.protocol ?\n        location.protocol.replace(':', '') :\n        'http';\n\n    // Check protocol map\n    protocol = (protocolMap[protocol] || defaultProtocol || protocol) + ':';\n    let urlParsed;\n\n    try {\n        urlParsed = new URLWithLegacySupport(url);\n    } catch (err) {\n        urlParsed = {};\n    }\n\n    const base = Object.assign({}, location, {\n        protocol: protocol || urlParsed.protocol,\n        host: location.host || urlParsed.host\n    });\n\n    return new URLWithLegacySupport(url, format(base)).toString();\n};\n","'use strict';\n\nconst defaultBase = self.location ?\n    self.location.protocol + '//' + self.location.host :\n    '';\nconst URL = self.URL;\n\nclass URLWithLegacySupport {\n    constructor(url = '', base = defaultBase) {\n        this.super = new URL(url, base);\n        this.path = this.pathname + this.search;\n        this.auth =\n            this.username && this.password ?\n                this.username + ':' + this.password :\n                null;\n\n        this.query =\n            this.search && this.search.startsWith('?') ?\n                this.search.slice(1) :\n                null;\n    }\n\n    get hash() {\n        return this.super.hash;\n    }\n    get host() {\n        return this.super.host;\n    }\n    get hostname() {\n        return this.super.hostname;\n    }\n    get href() {\n        return this.super.href;\n    }\n    get origin() {\n        return this.super.origin;\n    }\n    get password() {\n        return this.super.password;\n    }\n    get pathname() {\n        return this.super.pathname;\n    }\n    get port() {\n        return this.super.port;\n    }\n    get protocol() {\n        return this.super.protocol;\n    }\n    get search() {\n        return this.super.search;\n    }\n    get searchParams() {\n        return this.super.searchParams;\n    }\n    get username() {\n        return this.super.username;\n    }\n\n    set hash(hash) {\n        this.super.hash = hash;\n    }\n    set host(host) {\n        this.super.host = host;\n    }\n    set hostname(hostname) {\n        this.super.hostname = hostname;\n    }\n    set href(href) {\n        this.super.href = href;\n    }\n    set origin(origin) {\n        this.super.origin = origin;\n    }\n    set password(password) {\n        this.super.password = password;\n    }\n    set pathname(pathname) {\n        this.super.pathname = pathname;\n    }\n    set port(port) {\n        this.super.port = port;\n    }\n    set protocol(protocol) {\n        this.super.protocol = protocol;\n    }\n    set search(search) {\n        this.super.search = search;\n    }\n    set searchParams(searchParams) {\n        this.super.searchParams = searchParams;\n    }\n    set username(username) {\n        this.super.username = username;\n    }\n\n    createObjectURL(o) {\n        return this.super.createObjectURL(o);\n    }\n    revokeObjectURL(o) {\n        this.super.revokeObjectURL(o);\n    }\n    toJSON() {\n        return this.super.toJSON();\n    }\n    toString() {\n        return this.super.toString();\n    }\n    format() {\n        return this.toString();\n    }\n}\n\nfunction format(obj) {\n    if (typeof obj === 'string') {\n        const url = new URL(obj);\n\n        return url.toString();\n    }\n\n    if (!(obj instanceof URL)) {\n        const userPass =\n            obj.username && obj.password ?\n                `${obj.username}:${obj.password}@` :\n                '';\n        const auth = obj.auth ? obj.auth + '@' : '';\n        const port = obj.port ? ':' + obj.port : '';\n        const protocol = obj.protocol ? obj.protocol + '//' : '';\n        const host = obj.host || '';\n        const hostname = obj.hostname || '';\n        const search = obj.search || (obj.query ? '?' + obj.query : '');\n        const hash = obj.hash || '';\n        const pathname = obj.pathname || '';\n        const path = obj.path || pathname + search;\n\n        return `${protocol}${userPass || auth}${host ||\n            hostname + port}${path}${hash}`;\n    }\n}\n\nmodule.exports = {\n    URLWithLegacySupport,\n    URLSearchParams: self.URLSearchParams,\n    defaultBase,\n    format\n};\n","/**\n * [js-sha256]{@link https://github.com/emn178/js-sha256}\n *\n * @version 0.9.0\n * @author Chen, Yi-Cyuan [emn178@gmail.com]\n * @copyright Chen, Yi-Cyuan 2014-2017\n * @license MIT\n */\n/*jslint bitwise: true */\n(function () {\n  'use strict';\n\n  var ERROR = 'input is invalid type';\n  var WINDOW = typeof window === 'object';\n  var root = WINDOW ? window : {};\n  if (root.JS_SHA256_NO_WINDOW) {\n    WINDOW = false;\n  }\n  var WEB_WORKER = !WINDOW && typeof self === 'object';\n  var NODE_JS = !root.JS_SHA256_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;\n  if (NODE_JS) {\n    root = global;\n  } else if (WEB_WORKER) {\n    root = self;\n  }\n  var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && typeof module === 'object' && module.exports;\n  var AMD = typeof define === 'function' && define.amd;\n  var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';\n  var HEX_CHARS = '0123456789abcdef'.split('');\n  var EXTRA = [-2147483648, 8388608, 32768, 128];\n  var SHIFT = [24, 16, 8, 0];\n  var K = [\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n  ];\n  var OUTPUT_TYPES = ['hex', 'array', 'digest', 'arrayBuffer'];\n\n  var blocks = [];\n\n  if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) {\n    Array.isArray = function (obj) {\n      return Object.prototype.toString.call(obj) === '[object Array]';\n    };\n  }\n\n  if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {\n    ArrayBuffer.isView = function (obj) {\n      return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;\n    };\n  }\n\n  var createOutputMethod = function (outputType, is224) {\n    return function (message) {\n      return new Sha256(is224, true).update(message)[outputType]();\n    };\n  };\n\n  var createMethod = function (is224) {\n    var method = createOutputMethod('hex', is224);\n    if (NODE_JS) {\n      method = nodeWrap(method, is224);\n    }\n    method.create = function () {\n      return new Sha256(is224);\n    };\n    method.update = function (message) {\n      return method.create().update(message);\n    };\n    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {\n      var type = OUTPUT_TYPES[i];\n      method[type] = createOutputMethod(type, is224);\n    }\n    return method;\n  };\n\n  var nodeWrap = function (method, is224) {\n    var crypto = eval(\"require('crypto')\");\n    var Buffer = eval(\"require('buffer').Buffer\");\n    var algorithm = is224 ? 'sha224' : 'sha256';\n    var nodeMethod = function (message) {\n      if (typeof message === 'string') {\n        return crypto.createHash(algorithm).update(message, 'utf8').digest('hex');\n      } else {\n        if (message === null || message === undefined) {\n          throw new Error(ERROR);\n        } else if (message.constructor === ArrayBuffer) {\n          message = new Uint8Array(message);\n        }\n      }\n      if (Array.isArray(message) || ArrayBuffer.isView(message) ||\n        message.constructor === Buffer) {\n        return crypto.createHash(algorithm).update(new Buffer(message)).digest('hex');\n      } else {\n        return method(message);\n      }\n    };\n    return nodeMethod;\n  };\n\n  var createHmacOutputMethod = function (outputType, is224) {\n    return function (key, message) {\n      return new HmacSha256(key, is224, true).update(message)[outputType]();\n    };\n  };\n\n  var createHmacMethod = function (is224) {\n    var method = createHmacOutputMethod('hex', is224);\n    method.create = function (key) {\n      return new HmacSha256(key, is224);\n    };\n    method.update = function (key, message) {\n      return method.create(key).update(message);\n    };\n    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {\n      var type = OUTPUT_TYPES[i];\n      method[type] = createHmacOutputMethod(type, is224);\n    }\n    return method;\n  };\n\n  function Sha256(is224, sharedMemory) {\n    if (sharedMemory) {\n      blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] =\n        blocks[4] = blocks[5] = blocks[6] = blocks[7] =\n        blocks[8] = blocks[9] = blocks[10] = blocks[11] =\n        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;\n      this.blocks = blocks;\n    } else {\n      this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n    }\n\n    if (is224) {\n      this.h0 = 0xc1059ed8;\n      this.h1 = 0x367cd507;\n      this.h2 = 0x3070dd17;\n      this.h3 = 0xf70e5939;\n      this.h4 = 0xffc00b31;\n      this.h5 = 0x68581511;\n      this.h6 = 0x64f98fa7;\n      this.h7 = 0xbefa4fa4;\n    } else { // 256\n      this.h0 = 0x6a09e667;\n      this.h1 = 0xbb67ae85;\n      this.h2 = 0x3c6ef372;\n      this.h3 = 0xa54ff53a;\n      this.h4 = 0x510e527f;\n      this.h5 = 0x9b05688c;\n      this.h6 = 0x1f83d9ab;\n      this.h7 = 0x5be0cd19;\n    }\n\n    this.block = this.start = this.bytes = this.hBytes = 0;\n    this.finalized = this.hashed = false;\n    this.first = true;\n    this.is224 = is224;\n  }\n\n  Sha256.prototype.update = function (message) {\n    if (this.finalized) {\n      return;\n    }\n    var notString, type = typeof message;\n    if (type !== 'string') {\n      if (type === 'object') {\n        if (message === null) {\n          throw new Error(ERROR);\n        } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {\n          message = new Uint8Array(message);\n        } else if (!Array.isArray(message)) {\n          if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {\n            throw new Error(ERROR);\n          }\n        }\n      } else {\n        throw new Error(ERROR);\n      }\n      notString = true;\n    }\n    var code, index = 0, i, length = message.length, blocks = this.blocks;\n\n    while (index < length) {\n      if (this.hashed) {\n        this.hashed = false;\n        blocks[0] = this.block;\n        blocks[16] = blocks[1] = blocks[2] = blocks[3] =\n          blocks[4] = blocks[5] = blocks[6] = blocks[7] =\n          blocks[8] = blocks[9] = blocks[10] = blocks[11] =\n          blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;\n      }\n\n      if (notString) {\n        for (i = this.start; index < length && i < 64; ++index) {\n          blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];\n        }\n      } else {\n        for (i = this.start; index < length && i < 64; ++index) {\n          code = message.charCodeAt(index);\n          if (code < 0x80) {\n            blocks[i >> 2] |= code << SHIFT[i++ & 3];\n          } else if (code < 0x800) {\n            blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];\n            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];\n          } else if (code < 0xd800 || code >= 0xe000) {\n            blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];\n            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];\n            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];\n          } else {\n            code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));\n            blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];\n            blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];\n            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];\n            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];\n          }\n        }\n      }\n\n      this.lastByteIndex = i;\n      this.bytes += i - this.start;\n      if (i >= 64) {\n        this.block = blocks[16];\n        this.start = i - 64;\n        this.hash();\n        this.hashed = true;\n      } else {\n        this.start = i;\n      }\n    }\n    if (this.bytes > 4294967295) {\n      this.hBytes += this.bytes / 4294967296 << 0;\n      this.bytes = this.bytes % 4294967296;\n    }\n    return this;\n  };\n\n  Sha256.prototype.finalize = function () {\n    if (this.finalized) {\n      return;\n    }\n    this.finalized = true;\n    var blocks = this.blocks, i = this.lastByteIndex;\n    blocks[16] = this.block;\n    blocks[i >> 2] |= EXTRA[i & 3];\n    this.block = blocks[16];\n    if (i >= 56) {\n      if (!this.hashed) {\n        this.hash();\n      }\n      blocks[0] = this.block;\n      blocks[16] = blocks[1] = blocks[2] = blocks[3] =\n        blocks[4] = blocks[5] = blocks[6] = blocks[7] =\n        blocks[8] = blocks[9] = blocks[10] = blocks[11] =\n        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;\n    }\n    blocks[14] = this.hBytes << 3 | this.bytes >>> 29;\n    blocks[15] = this.bytes << 3;\n    this.hash();\n  };\n\n  Sha256.prototype.hash = function () {\n    var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4, f = this.h5, g = this.h6,\n      h = this.h7, blocks = this.blocks, j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc;\n\n    for (j = 16; j < 64; ++j) {\n      // rightrotate\n      t1 = blocks[j - 15];\n      s0 = ((t1 >>> 7) | (t1 << 25)) ^ ((t1 >>> 18) | (t1 << 14)) ^ (t1 >>> 3);\n      t1 = blocks[j - 2];\n      s1 = ((t1 >>> 17) | (t1 << 15)) ^ ((t1 >>> 19) | (t1 << 13)) ^ (t1 >>> 10);\n      blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1 << 0;\n    }\n\n    bc = b & c;\n    for (j = 0; j < 64; j += 4) {\n      if (this.first) {\n        if (this.is224) {\n          ab = 300032;\n          t1 = blocks[0] - 1413257819;\n          h = t1 - 150054599 << 0;\n          d = t1 + 24177077 << 0;\n        } else {\n          ab = 704751109;\n          t1 = blocks[0] - 210244248;\n          h = t1 - 1521486534 << 0;\n          d = t1 + 143694565 << 0;\n        }\n        this.first = false;\n      } else {\n        s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));\n        s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));\n        ab = a & b;\n        maj = ab ^ (a & c) ^ bc;\n        ch = (e & f) ^ (~e & g);\n        t1 = h + s1 + ch + K[j] + blocks[j];\n        t2 = s0 + maj;\n        h = d + t1 << 0;\n        d = t1 + t2 << 0;\n      }\n      s0 = ((d >>> 2) | (d << 30)) ^ ((d >>> 13) | (d << 19)) ^ ((d >>> 22) | (d << 10));\n      s1 = ((h >>> 6) | (h << 26)) ^ ((h >>> 11) | (h << 21)) ^ ((h >>> 25) | (h << 7));\n      da = d & a;\n      maj = da ^ (d & b) ^ ab;\n      ch = (h & e) ^ (~h & f);\n      t1 = g + s1 + ch + K[j + 1] + blocks[j + 1];\n      t2 = s0 + maj;\n      g = c + t1 << 0;\n      c = t1 + t2 << 0;\n      s0 = ((c >>> 2) | (c << 30)) ^ ((c >>> 13) | (c << 19)) ^ ((c >>> 22) | (c << 10));\n      s1 = ((g >>> 6) | (g << 26)) ^ ((g >>> 11) | (g << 21)) ^ ((g >>> 25) | (g << 7));\n      cd = c & d;\n      maj = cd ^ (c & a) ^ da;\n      ch = (g & h) ^ (~g & e);\n      t1 = f + s1 + ch + K[j + 2] + blocks[j + 2];\n      t2 = s0 + maj;\n      f = b + t1 << 0;\n      b = t1 + t2 << 0;\n      s0 = ((b >>> 2) | (b << 30)) ^ ((b >>> 13) | (b << 19)) ^ ((b >>> 22) | (b << 10));\n      s1 = ((f >>> 6) | (f << 26)) ^ ((f >>> 11) | (f << 21)) ^ ((f >>> 25) | (f << 7));\n      bc = b & c;\n      maj = bc ^ (b & d) ^ cd;\n      ch = (f & g) ^ (~f & h);\n      t1 = e + s1 + ch + K[j + 3] + blocks[j + 3];\n      t2 = s0 + maj;\n      e = a + t1 << 0;\n      a = t1 + t2 << 0;\n    }\n\n    this.h0 = this.h0 + a << 0;\n    this.h1 = this.h1 + b << 0;\n    this.h2 = this.h2 + c << 0;\n    this.h3 = this.h3 + d << 0;\n    this.h4 = this.h4 + e << 0;\n    this.h5 = this.h5 + f << 0;\n    this.h6 = this.h6 + g << 0;\n    this.h7 = this.h7 + h << 0;\n  };\n\n  Sha256.prototype.hex = function () {\n    this.finalize();\n\n    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,\n      h6 = this.h6, h7 = this.h7;\n\n    var hex = HEX_CHARS[(h0 >> 28) & 0x0F] + HEX_CHARS[(h0 >> 24) & 0x0F] +\n      HEX_CHARS[(h0 >> 20) & 0x0F] + HEX_CHARS[(h0 >> 16) & 0x0F] +\n      HEX_CHARS[(h0 >> 12) & 0x0F] + HEX_CHARS[(h0 >> 8) & 0x0F] +\n      HEX_CHARS[(h0 >> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +\n      HEX_CHARS[(h1 >> 28) & 0x0F] + HEX_CHARS[(h1 >> 24) & 0x0F] +\n      HEX_CHARS[(h1 >> 20) & 0x0F] + HEX_CHARS[(h1 >> 16) & 0x0F] +\n      HEX_CHARS[(h1 >> 12) & 0x0F] + HEX_CHARS[(h1 >> 8) & 0x0F] +\n      HEX_CHARS[(h1 >> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +\n      HEX_CHARS[(h2 >> 28) & 0x0F] + HEX_CHARS[(h2 >> 24) & 0x0F] +\n      HEX_CHARS[(h2 >> 20) & 0x0F] + HEX_CHARS[(h2 >> 16) & 0x0F] +\n      HEX_CHARS[(h2 >> 12) & 0x0F] + HEX_CHARS[(h2 >> 8) & 0x0F] +\n      HEX_CHARS[(h2 >> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +\n      HEX_CHARS[(h3 >> 28) & 0x0F] + HEX_CHARS[(h3 >> 24) & 0x0F] +\n      HEX_CHARS[(h3 >> 20) & 0x0F] + HEX_CHARS[(h3 >> 16) & 0x0F] +\n      HEX_CHARS[(h3 >> 12) & 0x0F] + HEX_CHARS[(h3 >> 8) & 0x0F] +\n      HEX_CHARS[(h3 >> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +\n      HEX_CHARS[(h4 >> 28) & 0x0F] + HEX_CHARS[(h4 >> 24) & 0x0F] +\n      HEX_CHARS[(h4 >> 20) & 0x0F] + HEX_CHARS[(h4 >> 16) & 0x0F] +\n      HEX_CHARS[(h4 >> 12) & 0x0F] + HEX_CHARS[(h4 >> 8) & 0x0F] +\n      HEX_CHARS[(h4 >> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F] +\n      HEX_CHARS[(h5 >> 28) & 0x0F] + HEX_CHARS[(h5 >> 24) & 0x0F] +\n      HEX_CHARS[(h5 >> 20) & 0x0F] + HEX_CHARS[(h5 >> 16) & 0x0F] +\n      HEX_CHARS[(h5 >> 12) & 0x0F] + HEX_CHARS[(h5 >> 8) & 0x0F] +\n      HEX_CHARS[(h5 >> 4) & 0x0F] + HEX_CHARS[h5 & 0x0F] +\n      HEX_CHARS[(h6 >> 28) & 0x0F] + HEX_CHARS[(h6 >> 24) & 0x0F] +\n      HEX_CHARS[(h6 >> 20) & 0x0F] + HEX_CHARS[(h6 >> 16) & 0x0F] +\n      HEX_CHARS[(h6 >> 12) & 0x0F] + HEX_CHARS[(h6 >> 8) & 0x0F] +\n      HEX_CHARS[(h6 >> 4) & 0x0F] + HEX_CHARS[h6 & 0x0F];\n    if (!this.is224) {\n      hex += HEX_CHARS[(h7 >> 28) & 0x0F] + HEX_CHARS[(h7 >> 24) & 0x0F] +\n        HEX_CHARS[(h7 >> 20) & 0x0F] + HEX_CHARS[(h7 >> 16) & 0x0F] +\n        HEX_CHARS[(h7 >> 12) & 0x0F] + HEX_CHARS[(h7 >> 8) & 0x0F] +\n        HEX_CHARS[(h7 >> 4) & 0x0F] + HEX_CHARS[h7 & 0x0F];\n    }\n    return hex;\n  };\n\n  Sha256.prototype.toString = Sha256.prototype.hex;\n\n  Sha256.prototype.digest = function () {\n    this.finalize();\n\n    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,\n      h6 = this.h6, h7 = this.h7;\n\n    var arr = [\n      (h0 >> 24) & 0xFF, (h0 >> 16) & 0xFF, (h0 >> 8) & 0xFF, h0 & 0xFF,\n      (h1 >> 24) & 0xFF, (h1 >> 16) & 0xFF, (h1 >> 8) & 0xFF, h1 & 0xFF,\n      (h2 >> 24) & 0xFF, (h2 >> 16) & 0xFF, (h2 >> 8) & 0xFF, h2 & 0xFF,\n      (h3 >> 24) & 0xFF, (h3 >> 16) & 0xFF, (h3 >> 8) & 0xFF, h3 & 0xFF,\n      (h4 >> 24) & 0xFF, (h4 >> 16) & 0xFF, (h4 >> 8) & 0xFF, h4 & 0xFF,\n      (h5 >> 24) & 0xFF, (h5 >> 16) & 0xFF, (h5 >> 8) & 0xFF, h5 & 0xFF,\n      (h6 >> 24) & 0xFF, (h6 >> 16) & 0xFF, (h6 >> 8) & 0xFF, h6 & 0xFF\n    ];\n    if (!this.is224) {\n      arr.push((h7 >> 24) & 0xFF, (h7 >> 16) & 0xFF, (h7 >> 8) & 0xFF, h7 & 0xFF);\n    }\n    return arr;\n  };\n\n  Sha256.prototype.array = Sha256.prototype.digest;\n\n  Sha256.prototype.arrayBuffer = function () {\n    this.finalize();\n\n    var buffer = new ArrayBuffer(this.is224 ? 28 : 32);\n    var dataView = new DataView(buffer);\n    dataView.setUint32(0, this.h0);\n    dataView.setUint32(4, this.h1);\n    dataView.setUint32(8, this.h2);\n    dataView.setUint32(12, this.h3);\n    dataView.setUint32(16, this.h4);\n    dataView.setUint32(20, this.h5);\n    dataView.setUint32(24, this.h6);\n    if (!this.is224) {\n      dataView.setUint32(28, this.h7);\n    }\n    return buffer;\n  };\n\n  function HmacSha256(key, is224, sharedMemory) {\n    var i, type = typeof key;\n    if (type === 'string') {\n      var bytes = [], length = key.length, index = 0, code;\n      for (i = 0; i < length; ++i) {\n        code = key.charCodeAt(i);\n        if (code < 0x80) {\n          bytes[index++] = code;\n        } else if (code < 0x800) {\n          bytes[index++] = (0xc0 | (code >> 6));\n          bytes[index++] = (0x80 | (code & 0x3f));\n        } else if (code < 0xd800 || code >= 0xe000) {\n          bytes[index++] = (0xe0 | (code >> 12));\n          bytes[index++] = (0x80 | ((code >> 6) & 0x3f));\n          bytes[index++] = (0x80 | (code & 0x3f));\n        } else {\n          code = 0x10000 + (((code & 0x3ff) << 10) | (key.charCodeAt(++i) & 0x3ff));\n          bytes[index++] = (0xf0 | (code >> 18));\n          bytes[index++] = (0x80 | ((code >> 12) & 0x3f));\n          bytes[index++] = (0x80 | ((code >> 6) & 0x3f));\n          bytes[index++] = (0x80 | (code & 0x3f));\n        }\n      }\n      key = bytes;\n    } else {\n      if (type === 'object') {\n        if (key === null) {\n          throw new Error(ERROR);\n        } else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {\n          key = new Uint8Array(key);\n        } else if (!Array.isArray(key)) {\n          if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {\n            throw new Error(ERROR);\n          }\n        }\n      } else {\n        throw new Error(ERROR);\n      }\n    }\n\n    if (key.length > 64) {\n      key = (new Sha256(is224, true)).update(key).array();\n    }\n\n    var oKeyPad = [], iKeyPad = [];\n    for (i = 0; i < 64; ++i) {\n      var b = key[i] || 0;\n      oKeyPad[i] = 0x5c ^ b;\n      iKeyPad[i] = 0x36 ^ b;\n    }\n\n    Sha256.call(this, is224, sharedMemory);\n\n    this.update(iKeyPad);\n    this.oKeyPad = oKeyPad;\n    this.inner = true;\n    this.sharedMemory = sharedMemory;\n  }\n  HmacSha256.prototype = new Sha256();\n\n  HmacSha256.prototype.finalize = function () {\n    Sha256.prototype.finalize.call(this);\n    if (this.inner) {\n      this.inner = false;\n      var innerHash = this.array();\n      Sha256.call(this, this.is224, this.sharedMemory);\n      this.update(this.oKeyPad);\n      this.update(innerHash);\n      Sha256.prototype.finalize.call(this);\n    }\n  };\n\n  var exports = createMethod();\n  exports.sha256 = exports;\n  exports.sha224 = createMethod(true);\n  exports.sha256.hmac = createHmacMethod();\n  exports.sha224.hmac = createHmacMethod(true);\n\n  if (COMMON_JS) {\n    module.exports = exports;\n  } else {\n    root.sha256 = exports.sha256;\n    root.sha224 = exports.sha224;\n    if (AMD) {\n      define(function () {\n        return exports;\n      });\n    }\n  }\n})();\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\n    result[\"default\"] = mod;\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./serializer\"));\nconst value = __importStar(require(\"./value\"));\nexports.value = value;\n//# sourceMappingURL=index.js.map","\"use strict\";\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\n    result[\"default\"] = mod;\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst cbor = __importStar(require(\"./value\"));\nconst BufferClasses = [\n    ArrayBuffer,\n    Uint8Array,\n    Uint16Array,\n    Uint32Array,\n    Int8Array,\n    Int16Array,\n    Int32Array,\n    Float32Array,\n    Float64Array,\n];\nclass JsonDefaultCborEncoder {\n    // @param _serializer The CBOR Serializer to use.\n    // @param _stable Whether or not keys from objects should be sorted (stable). This is\n    //     particularly useful when testing encodings between JSON objects.\n    constructor(_serializer, _stable = false) {\n        this._serializer = _serializer;\n        this._stable = _stable;\n        this.name = \"jsonDefault\";\n        this.priority = -100;\n    }\n    match(value) {\n        return [\"undefined\", \"boolean\", \"number\", \"string\", \"object\"].indexOf(typeof value) != -1;\n    }\n    encode(value) {\n        switch (typeof value) {\n            case \"undefined\":\n                return cbor.undefined_();\n            case \"boolean\":\n                return cbor.bool(value);\n            case \"number\":\n                if (Math.floor(value) === value) {\n                    return cbor.number(value);\n                }\n                else {\n                    return cbor.doubleFloat(value);\n                }\n            case \"string\":\n                return cbor.string(value);\n            case \"object\":\n                if (value === null) {\n                    return cbor.null_();\n                }\n                else if (Array.isArray(value)) {\n                    return cbor.array(value.map((x) => this._serializer.serializeValue(x)));\n                }\n                else if (BufferClasses.find((x) => value instanceof x)) {\n                    return cbor.bytes(value.buffer);\n                }\n                else if (Object.getOwnPropertyNames(value).indexOf(\"toJSON\") !== -1) {\n                    return this.encode(value.toJSON());\n                }\n                else if (value instanceof Map) {\n                    const m = new Map();\n                    for (const [key, item] of value.entries()) {\n                        m.set(key, this._serializer.serializeValue(item));\n                    }\n                    return cbor.map(m, this._stable);\n                }\n                else {\n                    const m = new Map();\n                    for (const [key, item] of Object.entries(value)) {\n                        m.set(key, this._serializer.serializeValue(item));\n                    }\n                    return cbor.map(m, this._stable);\n                }\n            default:\n                throw new Error(\"Invalid value.\");\n        }\n    }\n}\nexports.JsonDefaultCborEncoder = JsonDefaultCborEncoder;\nclass ToCborEncoder {\n    constructor() {\n        this.name = \"cborEncoder\";\n        this.priority = -90;\n    }\n    match(value) {\n        return typeof value == \"object\" && typeof value[\"toCBOR\"] == \"function\";\n    }\n    encode(value) {\n        return value.toCBOR();\n    }\n}\nexports.ToCborEncoder = ToCborEncoder;\nclass CborSerializer {\n    constructor() {\n        this._encoders = new Set();\n    }\n    static withDefaultEncoders(stable = false) {\n        const s = new this();\n        s.addEncoder(new JsonDefaultCborEncoder(s, stable));\n        s.addEncoder(new ToCborEncoder());\n        return s;\n    }\n    removeEncoder(name) {\n        // Has to make an extra call to values() to ensure it doesn't break on iteration.\n        for (const encoder of this._encoders.values()) {\n            if (encoder.name == name) {\n                this._encoders.delete(encoder);\n            }\n        }\n    }\n    addEncoder(encoder) {\n        this._encoders.add(encoder);\n    }\n    getEncoderFor(value) {\n        let chosenEncoder = null;\n        for (const encoder of this._encoders) {\n            if (!chosenEncoder || encoder.priority > chosenEncoder.priority) {\n                if (encoder.match(value)) {\n                    chosenEncoder = encoder;\n                }\n            }\n        }\n        if (chosenEncoder === null) {\n            throw new Error(\"Could not find an encoder for value.\");\n        }\n        return chosenEncoder;\n    }\n    serializeValue(value) {\n        return this.getEncoderFor(value).encode(value);\n    }\n    serialize(value) {\n        return this.serializeValue(value);\n    }\n}\nexports.CborSerializer = CborSerializer;\nclass SelfDescribeCborSerializer extends CborSerializer {\n    serialize(value) {\n        return cbor.raw(new Uint8Array([\n            // Self describe CBOR.\n            ...new Uint8Array([0xd9, 0xd9, 0xf7]),\n            ...new Uint8Array(super.serializeValue(value)),\n        ]));\n    }\n}\nexports.SelfDescribeCborSerializer = SelfDescribeCborSerializer;\n//# sourceMappingURL=serializer.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst MAX_U64_NUMBER = 0x20000000000000;\nfunction _concat(a, ...args) {\n    const newBuffer = new Uint8Array(a.byteLength + args.reduce((acc, b) => acc + b.byteLength, 0));\n    newBuffer.set(new Uint8Array(a), 0);\n    let i = a.byteLength;\n    for (const b of args) {\n        newBuffer.set(new Uint8Array(b), i);\n        i += b.byteLength;\n    }\n    return newBuffer.buffer;\n}\nfunction _serializeValue(major, minor, value) {\n    // Remove everything that's not an hexadecimal character. These are not\n    // considered errors since the value was already validated and they might\n    // be number decimals or sign.\n    value = value.replace(/[^0-9a-fA-F]/g, \"\");\n    // Create the buffer from the value with left padding with 0.\n    const length = 2 ** (minor - 24 /* Int8 */);\n    value = value.slice(-length * 2).padStart(length * 2, \"0\");\n    const bytes = [(major << 5) + minor].concat(value.match(/../g).map((byte) => parseInt(byte, 16)));\n    return new Uint8Array(bytes).buffer;\n}\nfunction _serializeNumber(major, value) {\n    if (value < 24) {\n        return new Uint8Array([(major << 5) + value]).buffer;\n    }\n    else {\n        const minor = value <= 0xff\n            ? 24 /* Int8 */\n            : value <= 0xffff\n                ? 25 /* Int16 */\n                : value <= 0xffffffff\n                    ? 26 /* Int32 */\n                    : 27 /* Int64 */;\n        return _serializeValue(major, minor, value.toString(16));\n    }\n}\nfunction _serializeString(str) {\n    const utf8 = [];\n    for (let i = 0; i < str.length; i++) {\n        let charcode = str.charCodeAt(i);\n        if (charcode < 0x80) {\n            utf8.push(charcode);\n        }\n        else if (charcode < 0x800) {\n            utf8.push(0xc0 | (charcode >> 6), 0x80 | (charcode & 0x3f));\n        }\n        else if (charcode < 0xd800 || charcode >= 0xe000) {\n            utf8.push(0xe0 | (charcode >> 12), 0x80 | ((charcode >> 6) & 0x3f), 0x80 | (charcode & 0x3f));\n        }\n        else {\n            // Surrogate pair\n            i++;\n            charcode = ((charcode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff);\n            utf8.push(0xf0 | (charcode >> 18), 0x80 | ((charcode >> 12) & 0x3f), 0x80 | ((charcode >> 6) & 0x3f), 0x80 | (charcode & 0x3f));\n        }\n    }\n    return _concat(new Uint8Array(_serializeNumber(3 /* TextString */, str.length)), new Uint8Array(utf8));\n}\n/**\n * Tag a value.\n */\nfunction tagged(tag, value) {\n    if (tag == 0xd9d9f7) {\n        return _concat(new Uint8Array([0xd9, 0xd9, 0xf7]), value);\n    }\n    if (tag < 24) {\n        return _concat(new Uint8Array([(6 /* Tag */ << 5) + tag]), value);\n    }\n    else {\n        const minor = tag <= 0xff\n            ? 24 /* Int8 */\n            : tag <= 0xffff\n                ? 25 /* Int16 */\n                : tag <= 0xffffffff\n                    ? 26 /* Int32 */\n                    : 27 /* Int64 */;\n        const length = 2 ** (minor - 24 /* Int8 */);\n        const value = tag\n            .toString(16)\n            .slice(-length * 2)\n            .padStart(length * 2, \"0\");\n        const bytes = [(6 /* Tag */ << 5) + minor].concat(value.match(/../g).map((byte) => parseInt(byte, 16)));\n        return new Uint8Array(bytes).buffer;\n    }\n}\nexports.tagged = tagged;\n/**\n * Set the raw bytes contained by this value. This should only be used with another\n * CborValue, or if you are implementing extensions to CBOR.\n * @param bytes A buffer containing the value.\n */\nfunction raw(bytes) {\n    return new Uint8Array(bytes).buffer;\n}\nexports.raw = raw;\n/**\n * Encode a number that is between [0, 23].\n * @param n\n */\nfunction uSmall(n) {\n    if (isNaN(n)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    n = Math.min(Math.max(0, n), 23); // Clamp it.\n    const bytes = [(0 /* UnsignedInteger */ << 5) + n];\n    return new Uint8Array(bytes).buffer;\n}\nexports.uSmall = uSmall;\nfunction u8(u8, radix) {\n    // Force u8 into a number, and validate it.\n    u8 = parseInt(\"\" + u8, radix);\n    if (isNaN(u8)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    u8 = Math.min(Math.max(0, u8), 0xff); // Clamp it.\n    u8 = u8.toString(16);\n    return _serializeValue(0 /* UnsignedInteger */, 24 /* Int8 */, u8);\n}\nexports.u8 = u8;\nfunction u16(u16, radix) {\n    // Force u16 into a number, and validate it.\n    u16 = parseInt(\"\" + u16, radix);\n    if (isNaN(u16)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    u16 = Math.min(Math.max(0, u16), 0xffff); // Clamp it.\n    u16 = u16.toString(16);\n    return _serializeValue(0 /* UnsignedInteger */, 25 /* Int16 */, u16);\n}\nexports.u16 = u16;\nfunction u32(u32, radix) {\n    // Force u32 into a number, and validate it.\n    u32 = parseInt(\"\" + u32, radix);\n    if (isNaN(u32)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    u32 = Math.min(Math.max(0, u32), 0xffffffff); // Clamp it.\n    u32 = u32.toString(16);\n    return _serializeValue(0 /* UnsignedInteger */, 26 /* Int32 */, u32);\n}\nexports.u32 = u32;\nfunction u64(u64, radix) {\n    // Special consideration for numbers that might be larger than expected.\n    if (typeof u64 == \"string\" && radix == 16) {\n        // This is the only case where we guarantee we'll encode the number directly.\n        // Validate it's all hexadecimal first.\n        if (u64.match(/[^0-9a-fA-F]/)) {\n            throw new RangeError(\"Invalid number.\");\n        }\n        return _serializeValue(0 /* UnsignedInteger */, 27 /* Int64 */, u64);\n    }\n    // Force u64 into a number, and validate it.\n    u64 = parseInt(\"\" + u64, radix);\n    if (isNaN(u64)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    u64 = Math.min(Math.max(0, u64), MAX_U64_NUMBER); // Clamp it to actual limit.\n    u64 = u64.toString(16);\n    return _serializeValue(0 /* UnsignedInteger */, 27 /* Int64 */, u64);\n}\nexports.u64 = u64;\n/**\n * Encode a negative number that is between [-24, -1].\n */\nfunction iSmall(n) {\n    if (isNaN(n)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    if (n === 0) {\n        return uSmall(0);\n    }\n    // Negative n, clamped to [1, 24], minus 1 (there's no negative 0).\n    n = Math.min(Math.max(0, -n), 24) - 1;\n    const bytes = [(1 /* SignedInteger */ << 5) + n];\n    return new Uint8Array(bytes).buffer;\n}\nexports.iSmall = iSmall;\nfunction i8(i8, radix) {\n    // Force i8 into a number, and validate it.\n    i8 = parseInt(\"\" + i8, radix);\n    if (isNaN(i8)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    // Negative n, clamped, minus 1 (there's no negative 0).\n    i8 = Math.min(Math.max(0, -i8 - 1), 0xff);\n    i8 = i8.toString(16);\n    return _serializeValue(1 /* SignedInteger */, 24 /* Int8 */, i8);\n}\nexports.i8 = i8;\nfunction i16(i16, radix) {\n    // Force i16 into a number, and validate it.\n    i16 = parseInt(\"\" + i16, radix);\n    if (isNaN(i16)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    // Negative n, clamped, minus 1 (there's no negative 0).\n    i16 = Math.min(Math.max(0, -i16 - 1), 0xffff);\n    i16 = i16.toString(16);\n    return _serializeValue(1 /* SignedInteger */, 25 /* Int16 */, i16);\n}\nexports.i16 = i16;\nfunction i32(i32, radix) {\n    // Force i32 into a number, and validate it.\n    i32 = parseInt(\"\" + i32, radix);\n    if (isNaN(i32)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    // Negative n, clamped, minus 1 (there's no negative 0).\n    i32 = Math.min(Math.max(0, -i32 - 1), 0xffffffff);\n    i32 = i32.toString(16);\n    return _serializeValue(1 /* SignedInteger */, 26 /* Int32 */, i32);\n}\nexports.i32 = i32;\nfunction i64(i64, radix) {\n    // Special consideration for numbers that might be larger than expected.\n    if (typeof i64 == \"string\" && radix == 16) {\n        if (i64.startsWith(\"-\")) {\n            i64 = i64.slice(1);\n        }\n        else {\n            // Clamp it.\n            i64 = \"0\";\n        }\n        // This is the only case where we guarantee we'll encode the number directly.\n        // Validate it's all hexadecimal first.\n        if (i64.match(/[^0-9a-fA-F]/) || i64.length > 16) {\n            throw new RangeError(\"Invalid number.\");\n        }\n        // We need to do -1 to the number.\n        let done = false;\n        let newI64 = i64.split(\"\").reduceRight((acc, x) => {\n            if (done) {\n                return x + acc;\n            }\n            let n = parseInt(x, 16) - 1;\n            if (n >= 0) {\n                done = true;\n                return n.toString(16) + acc;\n            }\n            else {\n                return \"f\" + acc;\n            }\n        }, \"\");\n        if (!done) {\n            // This number was 0.\n            return u64(0);\n        }\n        return _serializeValue(1 /* SignedInteger */, 27 /* Int64 */, newI64);\n    }\n    // Force i64 into a number, and validate it.\n    i64 = parseInt(\"\" + i64, radix);\n    if (isNaN(i64)) {\n        throw new RangeError(\"Invalid number.\");\n    }\n    i64 = Math.min(Math.max(0, -i64 - 1), 0x20000000000000); // Clamp it to actual.\n    i64 = i64.toString(16);\n    return _serializeValue(1 /* SignedInteger */, 27 /* Int64 */, i64);\n}\nexports.i64 = i64;\n/**\n * Encode a number using the smallest amount of bytes, by calling the methods\n * above. e.g. If the number fits in a u8, it will use that.\n */\nfunction number(n) {\n    if (n >= 0) {\n        if (n < 24) {\n            return uSmall(n);\n        }\n        else if (n <= 0xff) {\n            return u8(n);\n        }\n        else if (n <= 0xffff) {\n            return u16(n);\n        }\n        else if (n <= 0xffffffff) {\n            return u32(n);\n        }\n        else {\n            return u64(n);\n        }\n    }\n    else {\n        if (n >= -24) {\n            return iSmall(n);\n        }\n        else if (n >= -0xff) {\n            return i8(n);\n        }\n        else if (n >= -0xffff) {\n            return i16(n);\n        }\n        else if (n >= -0xffffffff) {\n            return i32(n);\n        }\n        else {\n            return i64(n);\n        }\n    }\n}\nexports.number = number;\n/**\n * Encode a byte array. This is different than the `raw()` method.\n */\nfunction bytes(bytes) {\n    return _concat(_serializeNumber(2 /* ByteString */, bytes.byteLength), bytes);\n}\nexports.bytes = bytes;\n/**\n * Encode a JavaScript string.\n */\nfunction string(str) {\n    return _serializeString(str);\n}\nexports.string = string;\n/**\n * Encode an array of cbor values.\n */\nfunction array(items) {\n    return _concat(_serializeNumber(4 /* Array */, items.length), ...items);\n}\nexports.array = array;\n/**\n * Encode a map of key-value pairs. The keys are string, and the values are CBOR\n * encoded.\n */\nfunction map(items, stable = false) {\n    if (!(items instanceof Map)) {\n        items = new Map(Object.entries(items));\n    }\n    let entries = Array.from(items.entries());\n    if (stable) {\n        entries = entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB));\n    }\n    return _concat(_serializeNumber(5 /* Map */, items.size), ...entries.map(([k, v]) => _concat(_serializeString(k), v)));\n}\nexports.map = map;\n/**\n * Encode a single (32 bits) precision floating point number.\n */\nfunction singleFloat(f) {\n    const single = new Float32Array([f]);\n    return _concat(new Uint8Array([(7 /* SimpleValue */ << 5) + 26]), new Uint8Array(single.buffer));\n}\nexports.singleFloat = singleFloat;\n/**\n * Encode a double (64 bits) precision floating point number.\n */\nfunction doubleFloat(f) {\n    const single = new Float64Array([f]);\n    return _concat(new Uint8Array([(7 /* SimpleValue */ << 5) + 27]), new Uint8Array(single.buffer));\n}\nexports.doubleFloat = doubleFloat;\nfunction bool(v) {\n    return v ? true_() : false_();\n}\nexports.bool = bool;\n/**\n * Encode the boolean true.\n */\nfunction true_() {\n    return raw(new Uint8Array([(7 /* SimpleValue */ << 5) + 21]));\n}\nexports.true_ = true_;\n/**\n * Encode the boolean false.\n */\nfunction false_() {\n    return raw(new Uint8Array([(7 /* SimpleValue */ << 5) + 20]));\n}\nexports.false_ = false_;\n/**\n * Encode the constant null.\n */\nfunction null_() {\n    return raw(new Uint8Array([(7 /* SimpleValue */ << 5) + 22]));\n}\nexports.null_ = null_;\n/**\n * Encode the constant undefined.\n */\nfunction undefined_() {\n    return raw(new Uint8Array([(7 /* SimpleValue */ << 5) + 23]));\n}\nexports.undefined_ = undefined_;\n//# sourceMappingURL=value.js.map","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tif(__webpack_module_cache__[moduleId]) {\n\t\treturn __webpack_module_cache__[moduleId].exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.amdO = {};","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * Codes used by the replica for rejecting a message.\n * See {@link https://sdk.dfinity.org/docs/interface-spec/#reject-codes | the interface spec}.\n */\nexport var ReplicaRejectCode;\n(function (ReplicaRejectCode) {\n    ReplicaRejectCode[ReplicaRejectCode[\"SysFatal\"] = 1] = \"SysFatal\";\n    ReplicaRejectCode[ReplicaRejectCode[\"SysTransient\"] = 2] = \"SysTransient\";\n    ReplicaRejectCode[ReplicaRejectCode[\"DestinationInvalid\"] = 3] = \"DestinationInvalid\";\n    ReplicaRejectCode[ReplicaRejectCode[\"CanisterReject\"] = 4] = \"CanisterReject\";\n    ReplicaRejectCode[ReplicaRejectCode[\"CanisterError\"] = 5] = \"CanisterError\";\n})(ReplicaRejectCode || (ReplicaRejectCode = {}));\n//# sourceMappingURL=api.js.map","// tslint:disable:no-bitwise\nconst alphabet = 'abcdefghijklmnopqrstuvwxyz234567';\n// Build a lookup table for decoding.\nconst lookupTable = Object.create(null);\nfor (let i = 0; i < alphabet.length; i++) {\n    lookupTable[alphabet[i]] = i;\n}\n// Add aliases for rfc4648.\nlookupTable['0'] = lookupTable.o;\nlookupTable['1'] = lookupTable.i;\n/**\n * @param input The input array to encode.\n * @returns A Base32 string encoding the input.\n */\nexport function encode(input) {\n    // How many bits will we skip from the first byte.\n    let skip = 0;\n    // 5 high bits, carry from one byte to the next.\n    let bits = 0;\n    // The output string in base32.\n    let output = '';\n    function encodeByte(byte) {\n        if (skip < 0) {\n            // we have a carry from the previous byte\n            bits |= byte >> -skip;\n        }\n        else {\n            // no carry\n            bits = (byte << skip) & 248;\n        }\n        if (skip > 3) {\n            // Not enough data to produce a character, get us another one\n            skip -= 8;\n            return 1;\n        }\n        if (skip < 4) {\n            // produce a character\n            output += alphabet[bits >> 3];\n            skip += 5;\n        }\n        return 0;\n    }\n    for (let i = 0; i < input.length;) {\n        i += encodeByte(input[i]);\n    }\n    return output + (skip < 0 ? alphabet[bits >> 3] : '');\n}\n/**\n * @param input The base32 encoded string to decode.\n */\nexport function decode(input) {\n    // how many bits we have from the previous character.\n    let skip = 0;\n    // current byte we're producing.\n    let byte = 0;\n    const output = new Uint8Array(((input.length * 4) / 3) | 0);\n    let o = 0;\n    function decodeChar(char) {\n        // Consume a character from the stream, store\n        // the output in this.output. As before, better\n        // to use update().\n        let val = lookupTable[char.toLowerCase()];\n        if (val === undefined) {\n            throw new Error(`Invalid character: ${JSON.stringify(char)}`);\n        }\n        // move to the high bits\n        val <<= 3;\n        byte |= val >>> skip;\n        skip += 5;\n        if (skip >= 8) {\n            // We have enough bytes to produce an output\n            output[o++] = byte;\n            skip -= 8;\n            if (skip > 0) {\n                byte = (val << (5 - skip)) & 255;\n            }\n            else {\n                byte = 0;\n            }\n        }\n    }\n    for (const c of input) {\n        decodeChar(c);\n    }\n    return output.slice(0, o);\n}\n//# sourceMappingURL=base32.js.map","// tslint:disable:no-bitwise\n// This file is translated to JavaScript from\n// https://lxp32.github.io/docs/a-simple-example-crc32-calculation/\nconst lookUpTable = new Uint32Array([\n    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,\n    0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,\n    0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,\n    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,\n    0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,\n    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,\n    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,\n    0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,\n    0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,\n    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,\n    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,\n    0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,\n    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,\n    0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,\n    0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,\n    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,\n    0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,\n    0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,\n    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,\n    0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,\n    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,\n    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,\n    0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,\n    0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,\n    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,\n    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,\n    0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,\n    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,\n    0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,\n    0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,\n    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,\n    0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,\n]);\n/**\n * Calculate the CRC32 of an ArrayBufferLike.\n * @param buf The BufferLike to calculate the CRC32 of.\n */\nexport function getCrc32(buf) {\n    const b = new Uint8Array(buf);\n    let crc = -1;\n    // tslint:disable-next-line:prefer-for-of\n    for (let i = 0; i < b.length; i++) {\n        const byte = b[i];\n        const t = (byte ^ crc) & 0xff;\n        crc = lookUpTable[t] ^ (crc >>> 8);\n    }\n    return (crc ^ -1) >>> 0;\n}\n//# sourceMappingURL=getCrc.js.map","import { decode, encode } from './utils/base32';\nimport { getCrc32 } from './utils/getCrc';\nimport { sha224 } from './utils/sha224';\nconst SELF_AUTHENTICATING_SUFFIX = 2;\nconst ANONYMOUS_SUFFIX = 4;\nconst fromHexString = (hexString) => { var _a; return new Uint8Array(((_a = hexString.match(/.{1,2}/g)) !== null && _a !== void 0 ? _a : []).map(byte => parseInt(byte, 16))); };\nconst toHexString = (bytes) => bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');\nexport class Principal {\n    constructor(_arr) {\n        this._arr = _arr;\n        this._isPrincipal = true;\n    }\n    static anonymous() {\n        return new this(new Uint8Array([ANONYMOUS_SUFFIX]));\n    }\n    static selfAuthenticating(publicKey) {\n        const sha = sha224(publicKey);\n        return new this(new Uint8Array([...sha, SELF_AUTHENTICATING_SUFFIX]));\n    }\n    static from(other) {\n        if (typeof other === 'string') {\n            return Principal.fromText(other);\n        }\n        else if (typeof other === 'object' &&\n            other !== null &&\n            other._isPrincipal === true) {\n            return new Principal(other._arr);\n        }\n        throw new Error(`Impossible to convert ${JSON.stringify(other)} to Principal.`);\n    }\n    static fromHex(hex) {\n        return new this(fromHexString(hex));\n    }\n    static fromText(text) {\n        const canisterIdNoDash = text.toLowerCase().replace(/-/g, '');\n        let arr = decode(canisterIdNoDash);\n        arr = arr.slice(4, arr.length);\n        const principal = new this(arr);\n        if (principal.toText() !== text) {\n            throw new Error(`Principal \"${principal.toText()}\" does not have a valid checksum.`);\n        }\n        return principal;\n    }\n    static fromUint8Array(arr) {\n        return new this(arr);\n    }\n    isAnonymous() {\n        return this._arr.byteLength === 1 && this._arr[0] === ANONYMOUS_SUFFIX;\n    }\n    toUint8Array() {\n        return this._arr;\n    }\n    toHex() {\n        return toHexString(this._arr).toUpperCase();\n    }\n    toText() {\n        const checksumArrayBuf = new ArrayBuffer(4);\n        const view = new DataView(checksumArrayBuf);\n        view.setUint32(0, getCrc32(this._arr));\n        const checksum = Uint8Array.from(Buffer.from(checksumArrayBuf));\n        const bytes = Uint8Array.from(this._arr);\n        const array = new Uint8Array([...checksum, ...bytes]);\n        const result = encode(array);\n        const matches = result.match(/.{1,5}/g);\n        if (!matches) {\n            // This should only happen if there's no character, which is unreachable.\n            throw new Error();\n        }\n        return matches.join('-');\n    }\n    toString() {\n        return this.toText();\n    }\n}\n//# sourceMappingURL=index.js.map","import { sha224 as jsSha224 } from 'js-sha256';\n/**\n *\n * @param data Arraybuffer to encode\n * @returns sha244-encoded BinaryBlob\n */\nexport function sha224(data) {\n    const shaObj = jsSha224.create();\n    shaObj.update(data);\n    return new Uint8Array(shaObj.array());\n}\n//# sourceMappingURL=sha224.js.map","import Pipe from 'buffer-pipe';\nimport { Buffer } from 'buffer/';\n/**\n *\n * @param pipe Pipe from buffer-pipe\n * @param num number\n * @returns Buffer\n */\nexport function safeRead(pipe, num) {\n    if (pipe.buffer.length < num) {\n        throw new Error('unexpected end of buffer');\n    }\n    return pipe.read(num);\n}\n/**\n * Encode a positive number (or bigint) into a Buffer. The number will be floored to the\n * nearest integer.\n * @param value The number to encode.\n */\nexport function lebEncode(value) {\n    if (typeof value === 'number') {\n        value = BigInt(value);\n    }\n    if (value < BigInt(0)) {\n        throw new Error('Cannot leb encode negative values.');\n    }\n    const pipe = new Pipe();\n    while (true) {\n        const i = Number(value & BigInt(0x7f));\n        value /= BigInt(0x80);\n        if (value === BigInt(0)) {\n            pipe.write([i]);\n            break;\n        }\n        else {\n            pipe.write([i | 0x80]);\n        }\n    }\n    return new Buffer(pipe.buffer);\n}\n/**\n * Decode a leb encoded buffer into a bigint. The number will always be positive (does not\n * support signed leb encoding).\n * @param pipe A Buffer containing the leb encoded bits.\n */\nexport function lebDecode(pipe) {\n    let weight = BigInt(1);\n    let value = BigInt(0);\n    let byte;\n    do {\n        byte = safeRead(pipe, 1)[0];\n        value += BigInt(byte & 0x7f).valueOf() * weight;\n        weight *= BigInt(128);\n    } while (byte >= 0x80);\n    return value;\n}\n/**\n * Encode a number (or bigint) into a Buffer, with support for negative numbers. The number\n * will be floored to the nearest integer.\n * @param value The number to encode.\n */\nexport function slebEncode(value) {\n    if (typeof value === 'number') {\n        value = BigInt(value);\n    }\n    const isNeg = value < BigInt(0);\n    if (isNeg) {\n        value = -value - BigInt(1);\n    }\n    const pipe = new Pipe();\n    while (true) {\n        const i = getLowerBytes(value);\n        value /= BigInt(0x80);\n        // prettier-ignore\n        if ((isNeg && value === BigInt(0) && (i & 0x40) !== 0)\n            || (!isNeg && value === BigInt(0) && (i & 0x40) === 0)) {\n            pipe.write([i]);\n            break;\n        }\n        else {\n            pipe.write([i | 0x80]);\n        }\n    }\n    function getLowerBytes(num) {\n        const bytes = num % BigInt(0x80);\n        if (isNeg) {\n            // We swap the bits here again, and remove 1 to do two's complement.\n            return Number(BigInt(0x80) - bytes - BigInt(1));\n        }\n        else {\n            return Number(bytes);\n        }\n    }\n    return new Buffer(pipe.buffer);\n}\n/**\n * Decode a leb encoded buffer into a bigint. The number is decoded with support for negative\n * signed-leb encoding.\n * @param pipe A Buffer containing the signed leb encoded bits.\n */\nexport function slebDecode(pipe) {\n    // Get the size of the buffer, then cut a buffer of that size.\n    const pipeView = new Uint8Array(pipe.buffer);\n    let len = 0;\n    for (; len < pipeView.byteLength; len++) {\n        if (pipeView[len] < 0x80) {\n            // If it's a positive number, we reuse lebDecode.\n            if ((pipeView[len] & 0x40) === 0) {\n                return lebDecode(pipe);\n            }\n            break;\n        }\n    }\n    const bytes = new Uint8Array(safeRead(pipe, len + 1));\n    let value = BigInt(0);\n    for (let i = bytes.byteLength - 1; i >= 0; i--) {\n        value = value * BigInt(0x80) + BigInt(0x80 - (bytes[i] & 0x7f) - 1);\n    }\n    return -value - BigInt(1);\n}\n/**\n *\n * @param value bigint or number\n * @param byteLength number\n * @returns Buffer\n */\nexport function writeUIntLE(value, byteLength) {\n    if (BigInt(value) < BigInt(0)) {\n        throw new Error('Cannot write negative values.');\n    }\n    return writeIntLE(value, byteLength);\n}\n/**\n *\n * @param value bigint | number\n * @param byteLength number\n * @returns Buffer\n */\nexport function writeIntLE(value, byteLength) {\n    value = BigInt(value);\n    const pipe = new Pipe();\n    let i = 0;\n    let mul = BigInt(256);\n    let sub = BigInt(0);\n    let byte = Number(value % mul);\n    pipe.write([byte]);\n    while (++i < byteLength) {\n        if (value < 0 && sub === BigInt(0) && byte !== 0) {\n            sub = BigInt(1);\n        }\n        byte = Number((value / mul - sub) % BigInt(256));\n        pipe.write([byte]);\n        mul *= BigInt(256);\n    }\n    return new Buffer(pipe.buffer);\n}\n/**\n *\n * @param pipe Pipe from buffer-pipe\n * @param byteLength number\n * @returns bigint\n */\nexport function readUIntLE(pipe, byteLength) {\n    let val = BigInt(safeRead(pipe, 1)[0]);\n    let mul = BigInt(1);\n    let i = 0;\n    while (++i < byteLength) {\n        mul *= BigInt(256);\n        const byte = BigInt(safeRead(pipe, 1)[0]);\n        val = val + mul * byte;\n    }\n    return val;\n}\n/**\n *\n * @param pipe Pipe from buffer-pipe\n * @param byteLength number\n * @returns bigint\n */\nexport function readIntLE(pipe, byteLength) {\n    let val = readUIntLE(pipe, byteLength);\n    const mul = BigInt(2) ** (BigInt(8) * BigInt(byteLength - 1) + BigInt(7));\n    if (val >= mul) {\n        val -= mul * BigInt(2);\n    }\n    return val;\n}\n//# sourceMappingURL=leb128.js.map","/* eslint-disable @typescript-eslint/no-empty-interface */\n/* eslint-disable jsdoc/require-jsdoc */\nimport { Buffer } from 'buffer/';\nimport { lebEncode } from './utils/leb128';\nexport function blobFromBuffer(b) {\n    return b;\n}\nexport function blobFromUint8Array(arr) {\n    return Buffer.from(arr);\n}\nexport function blobFromText(text) {\n    return Buffer.from(text);\n}\nexport function blobFromUint32Array(arr) {\n    return Buffer.from(arr);\n}\nexport function derBlobFromBlob(blob) {\n    return blob;\n}\nexport function blobFromHex(hex) {\n    return Buffer.from(hex, 'hex');\n}\nexport function blobToHex(blob) {\n    return blob.toString('hex');\n}\nexport function blobToUint8Array(blob) {\n    return new Uint8Array(blob.slice(0, blob.byteLength));\n}\n/**\n * Create a random Nonce, based on date and a random suffix.\n */\nexport function makeNonce() {\n    return lebEncode(BigInt(+Date.now()) * BigInt(100000) + BigInt(Math.floor(Math.random() * 100000)));\n}\n//# sourceMappingURL=types.js.map","/**\n * Hashes a string to a number. Algorithm can be found here:\n * https://caml.inria.fr/pub/papers/garrigue-polymorphic_variants-ml98.pdf\n * @param s\n */\nfunction idlHash(s) {\n    const utf8encoder = new TextEncoder();\n    const array = utf8encoder.encode(s);\n    let h = 0;\n    for (const c of array) {\n        h = (h * 223 + c) % 2 ** 32;\n    }\n    return h;\n}\n/**\n *\n * @param label string\n * @returns number representing hashed label\n */\nexport function idlLabelToId(label) {\n    if (/^_\\d+_$/.test(label) || /^_0x[0-9a-fA-F]+_$/.test(label)) {\n        const num = +label.slice(1, -1);\n        if (Number.isSafeInteger(num) && num >= 0 && num < 2 ** 32) {\n            return num;\n        }\n    }\n    return idlHash(label);\n}\n//# sourceMappingURL=hash.js.map","// tslint:disable:max-classes-per-file\nimport Pipe from 'buffer-pipe';\nimport { Buffer } from 'buffer/';\nimport { Principal as PrincipalId } from '@dfinity/principal';\nimport { blobFromBuffer } from './types';\nimport { idlLabelToId } from './utils/hash';\nimport { lebDecode, lebEncode, safeRead, slebDecode, slebEncode } from './utils/leb128';\nimport { readIntLE, readUIntLE, writeIntLE, writeUIntLE } from './utils/leb128';\nconst magicNumber = 'DIDL';\nfunction zipWith(xs, ys, f) {\n    return xs.map((x, i) => f(x, ys[i]));\n}\n/**\n * An IDL Type Table, which precedes the data in the stream.\n */\nclass TypeTable {\n    constructor() {\n        // List of types. Needs to be an array as the index needs to be stable.\n        this._typs = [];\n        this._idx = new Map();\n    }\n    has(obj) {\n        return this._idx.has(obj.name);\n    }\n    add(type, buf) {\n        const idx = this._typs.length;\n        this._idx.set(type.name, idx);\n        this._typs.push(buf);\n    }\n    merge(obj, knot) {\n        const idx = this._idx.get(obj.name);\n        const knotIdx = this._idx.get(knot);\n        if (idx === undefined) {\n            throw new Error('Missing type index for ' + obj);\n        }\n        if (knotIdx === undefined) {\n            throw new Error('Missing type index for ' + knot);\n        }\n        this._typs[idx] = this._typs[knotIdx];\n        // Delete the type.\n        this._typs.splice(knotIdx, 1);\n        this._idx.delete(knot);\n    }\n    encode() {\n        const len = lebEncode(this._typs.length);\n        const buf = Buffer.concat(this._typs);\n        return Buffer.concat([len, buf]);\n    }\n    indexOf(typeName) {\n        if (!this._idx.has(typeName)) {\n            throw new Error('Missing type index for ' + typeName);\n        }\n        return slebEncode(this._idx.get(typeName) || 0);\n    }\n}\nexport class Visitor {\n    visitType(t, data) {\n        throw new Error('Not implemented');\n    }\n    visitPrimitive(t, data) {\n        return this.visitType(t, data);\n    }\n    visitEmpty(t, data) {\n        return this.visitPrimitive(t, data);\n    }\n    visitBool(t, data) {\n        return this.visitPrimitive(t, data);\n    }\n    visitNull(t, data) {\n        return this.visitPrimitive(t, data);\n    }\n    visitReserved(t, data) {\n        return this.visitPrimitive(t, data);\n    }\n    visitText(t, data) {\n        return this.visitPrimitive(t, data);\n    }\n    visitNumber(t, data) {\n        return this.visitPrimitive(t, data);\n    }\n    visitInt(t, data) {\n        return this.visitNumber(t, data);\n    }\n    visitNat(t, data) {\n        return this.visitNumber(t, data);\n    }\n    visitFloat(t, data) {\n        return this.visitPrimitive(t, data);\n    }\n    visitFixedInt(t, data) {\n        return this.visitNumber(t, data);\n    }\n    visitFixedNat(t, data) {\n        return this.visitNumber(t, data);\n    }\n    visitPrincipal(t, data) {\n        return this.visitPrimitive(t, data);\n    }\n    visitConstruct(t, data) {\n        return this.visitType(t, data);\n    }\n    visitVec(t, ty, data) {\n        return this.visitConstruct(t, data);\n    }\n    visitOpt(t, ty, data) {\n        return this.visitConstruct(t, data);\n    }\n    visitRecord(t, fields, data) {\n        return this.visitConstruct(t, data);\n    }\n    visitTuple(t, components, data) {\n        const fields = components.map((ty, i) => [`_${i}_`, ty]);\n        return this.visitRecord(t, fields, data);\n    }\n    visitVariant(t, fields, data) {\n        return this.visitConstruct(t, data);\n    }\n    visitRec(t, ty, data) {\n        return this.visitConstruct(ty, data);\n    }\n    visitFunc(t, data) {\n        return this.visitConstruct(t, data);\n    }\n    visitService(t, data) {\n        return this.visitConstruct(t, data);\n    }\n}\n/**\n * Represents an IDL type.\n */\nexport class Type {\n    /* Display type name */\n    display() {\n        return this.name;\n    }\n    valueToString(x) {\n        return JSON.stringify(x);\n    }\n    /* Implement `T` in the IDL spec, only needed for non-primitive types */\n    buildTypeTable(typeTable) {\n        if (!typeTable.has(this)) {\n            this._buildTypeTableImpl(typeTable);\n        }\n    }\n}\nexport class PrimitiveType extends Type {\n    checkType(t) {\n        if (this.name !== t.name) {\n            throw new Error(`type mismatch: type on the wire ${t.name}, expect type ${this.name}`);\n        }\n        return t;\n    }\n    _buildTypeTableImpl(typeTable) {\n        // No type table encoding for Primitive types.\n        return;\n    }\n}\nexport class ConstructType extends Type {\n    checkType(t) {\n        if (t instanceof RecClass) {\n            const ty = t.getType();\n            if (typeof ty === 'undefined') {\n                throw new Error('type mismatch with uninitialized type');\n            }\n            return ty;\n        }\n        throw new Error(`type mismatch: type on the wire ${t.name}, expect type ${this.name}`);\n    }\n    encodeType(typeTable) {\n        return typeTable.indexOf(this.name);\n    }\n}\n/**\n * Represents an IDL Empty, a type which has no inhabitants.\n * Since no values exist for this type, it cannot be serialised or deserialised.\n * Result types like `Result<Text, Empty>` should always succeed.\n */\nexport class EmptyClass extends PrimitiveType {\n    accept(v, d) {\n        return v.visitEmpty(this, d);\n    }\n    covariant(x) {\n        return false;\n    }\n    encodeValue() {\n        throw new Error('Empty cannot appear as a function argument');\n    }\n    valueToString() {\n        throw new Error('Empty cannot appear as a value');\n    }\n    encodeType() {\n        return slebEncode(-17 /* Empty */);\n    }\n    decodeValue() {\n        throw new Error('Empty cannot appear as an output');\n    }\n    get name() {\n        return 'empty';\n    }\n}\n/**\n * Represents an IDL Bool\n */\nexport class BoolClass extends PrimitiveType {\n    accept(v, d) {\n        return v.visitBool(this, d);\n    }\n    covariant(x) {\n        return typeof x === 'boolean';\n    }\n    encodeValue(x) {\n        const buf = Buffer.alloc(1);\n        buf.writeInt8(x ? 1 : 0, 0);\n        return buf;\n    }\n    encodeType() {\n        return slebEncode(-2 /* Bool */);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        const x = safeRead(b, 1).toString('hex');\n        if (x === '00') {\n            return false;\n        }\n        else if (x === '01') {\n            return true;\n        }\n        else {\n            throw new Error('Boolean value out of range');\n        }\n    }\n    get name() {\n        return 'bool';\n    }\n}\n/**\n * Represents an IDL Null\n */\nexport class NullClass extends PrimitiveType {\n    accept(v, d) {\n        return v.visitNull(this, d);\n    }\n    covariant(x) {\n        return x === null;\n    }\n    encodeValue() {\n        return Buffer.alloc(0);\n    }\n    encodeType() {\n        return slebEncode(-1 /* Null */);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        return null;\n    }\n    get name() {\n        return 'null';\n    }\n}\n/**\n * Represents an IDL Reserved\n */\nexport class ReservedClass extends PrimitiveType {\n    accept(v, d) {\n        return v.visitReserved(this, d);\n    }\n    covariant(x) {\n        return true;\n    }\n    encodeValue() {\n        return Buffer.alloc(0);\n    }\n    encodeType() {\n        return slebEncode(-16 /* Reserved */);\n    }\n    decodeValue(b, t) {\n        if (t.name !== this.name) {\n            t.decodeValue(b, t);\n        }\n        return null;\n    }\n    get name() {\n        return 'reserved';\n    }\n}\nfunction isValidUTF8(buf) {\n    return Buffer.compare(new Buffer(buf.toString(), 'utf8'), buf) === 0;\n}\n/**\n * Represents an IDL Text\n */\nexport class TextClass extends PrimitiveType {\n    accept(v, d) {\n        return v.visitText(this, d);\n    }\n    covariant(x) {\n        return typeof x === 'string';\n    }\n    encodeValue(x) {\n        const buf = Buffer.from(x, 'utf8');\n        const len = lebEncode(buf.length);\n        return Buffer.concat([len, buf]);\n    }\n    encodeType() {\n        return slebEncode(-15 /* Text */);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        const len = lebDecode(b);\n        const buf = safeRead(b, Number(len));\n        if (!isValidUTF8(buf)) {\n            throw new Error('Not valid UTF8 text');\n        }\n        return buf.toString('utf8');\n    }\n    get name() {\n        return 'text';\n    }\n    valueToString(x) {\n        return '\"' + x + '\"';\n    }\n}\n/**\n * Represents an IDL Int\n */\nexport class IntClass extends PrimitiveType {\n    accept(v, d) {\n        return v.visitInt(this, d);\n    }\n    covariant(x) {\n        // We allow encoding of JavaScript plain numbers.\n        // But we will always decode to bigint.\n        return typeof x === 'bigint' || Number.isInteger(x);\n    }\n    encodeValue(x) {\n        return slebEncode(x);\n    }\n    encodeType() {\n        return slebEncode(-4 /* Int */);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        return slebDecode(b);\n    }\n    get name() {\n        return 'int';\n    }\n    valueToString(x) {\n        return x.toString();\n    }\n}\n/**\n * Represents an IDL Nat\n */\nexport class NatClass extends PrimitiveType {\n    accept(v, d) {\n        return v.visitNat(this, d);\n    }\n    covariant(x) {\n        // We allow encoding of JavaScript plain numbers.\n        // But we will always decode to bigint.\n        return (typeof x === 'bigint' && x >= BigInt(0)) || (Number.isInteger(x) && x >= 0);\n    }\n    encodeValue(x) {\n        return lebEncode(x);\n    }\n    encodeType() {\n        return slebEncode(-3 /* Nat */);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        return lebDecode(b);\n    }\n    get name() {\n        return 'nat';\n    }\n    valueToString(x) {\n        return x.toString();\n    }\n}\n/**\n * Represents an IDL Float\n */\nexport class FloatClass extends PrimitiveType {\n    constructor(_bits) {\n        super();\n        this._bits = _bits;\n        if (_bits !== 32 && _bits !== 64) {\n            throw new Error('not a valid float type');\n        }\n    }\n    accept(v, d) {\n        return v.visitFloat(this, d);\n    }\n    covariant(x) {\n        return typeof x === 'number' || x instanceof Number;\n    }\n    encodeValue(x) {\n        const buf = Buffer.allocUnsafe(this._bits / 8);\n        if (this._bits === 32) {\n            buf.writeFloatLE(x, 0);\n        }\n        else {\n            buf.writeDoubleLE(x, 0);\n        }\n        return buf;\n    }\n    encodeType() {\n        const opcode = this._bits === 32 ? -13 /* Float32 */ : -14 /* Float64 */;\n        return slebEncode(opcode);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        const x = safeRead(b, this._bits / 8);\n        if (this._bits === 32) {\n            return x.readFloatLE(0);\n        }\n        else {\n            return x.readDoubleLE(0);\n        }\n    }\n    get name() {\n        return 'float' + this._bits;\n    }\n    valueToString(x) {\n        return x.toString();\n    }\n}\n/**\n * Represents an IDL fixed-width Int(n)\n */\nexport class FixedIntClass extends PrimitiveType {\n    constructor(_bits) {\n        super();\n        this._bits = _bits;\n    }\n    accept(v, d) {\n        return v.visitFixedInt(this, d);\n    }\n    covariant(x) {\n        const min = BigInt(2) ** BigInt(this._bits - 1) * BigInt(-1);\n        const max = BigInt(2) ** BigInt(this._bits - 1) - BigInt(1);\n        if (typeof x === 'bigint') {\n            return x >= min && x <= max;\n        }\n        else if (Number.isInteger(x)) {\n            const v = BigInt(x);\n            return v >= min && v <= max;\n        }\n        else {\n            return false;\n        }\n    }\n    encodeValue(x) {\n        return writeIntLE(x, this._bits / 8);\n    }\n    encodeType() {\n        const offset = Math.log2(this._bits) - 3;\n        return slebEncode(-9 - offset);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        const num = readIntLE(b, this._bits / 8);\n        if (this._bits <= 32) {\n            return Number(num);\n        }\n        else {\n            return num;\n        }\n    }\n    get name() {\n        return `int${this._bits}`;\n    }\n    valueToString(x) {\n        return x.toString();\n    }\n}\n/**\n * Represents an IDL fixed-width Nat(n)\n */\nexport class FixedNatClass extends PrimitiveType {\n    constructor(bits) {\n        super();\n        this.bits = bits;\n    }\n    accept(v, d) {\n        return v.visitFixedNat(this, d);\n    }\n    covariant(x) {\n        const max = BigInt(2) ** BigInt(this.bits);\n        if (typeof x === 'bigint' && x >= BigInt(0)) {\n            return x < max;\n        }\n        else if (Number.isInteger(x) && x >= 0) {\n            const v = BigInt(x);\n            return v < max;\n        }\n        else {\n            return false;\n        }\n    }\n    encodeValue(x) {\n        return writeUIntLE(x, this.bits / 8);\n    }\n    encodeType() {\n        const offset = Math.log2(this.bits) - 3;\n        return slebEncode(-5 - offset);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        const num = readUIntLE(b, this.bits / 8);\n        if (this.bits <= 32) {\n            return Number(num);\n        }\n        else {\n            return num;\n        }\n    }\n    get name() {\n        return `nat${this.bits}`;\n    }\n    valueToString(x) {\n        return x.toString();\n    }\n}\n/**\n * Represents an IDL Array\n * @param {Type} t\n */\nexport class VecClass extends ConstructType {\n    constructor(_type) {\n        super();\n        this._type = _type;\n        // If true, this vector is really a blob and we can just use memcpy.\n        this._blobOptimization = false;\n        if (_type instanceof FixedNatClass && _type.bits === 8) {\n            this._blobOptimization = true;\n        }\n    }\n    accept(v, d) {\n        return v.visitVec(this, this._type, d);\n    }\n    covariant(x) {\n        return Array.isArray(x) && x.every(v => this._type.covariant(v));\n    }\n    encodeValue(x) {\n        const len = lebEncode(x.length);\n        if (this._blobOptimization) {\n            return Buffer.concat([len, Buffer.from(x)]);\n        }\n        return Buffer.concat([len, ...x.map(d => this._type.encodeValue(d))]);\n    }\n    _buildTypeTableImpl(typeTable) {\n        this._type.buildTypeTable(typeTable);\n        const opCode = slebEncode(-19 /* Vector */);\n        const buffer = this._type.encodeType(typeTable);\n        typeTable.add(this, Buffer.concat([opCode, buffer]));\n    }\n    decodeValue(b, t) {\n        const vec = this.checkType(t);\n        if (!(vec instanceof VecClass)) {\n            throw new Error('Not a vector type');\n        }\n        const len = Number(lebDecode(b));\n        if (this._blobOptimization) {\n            return [...new Uint8Array(b.read(len))];\n        }\n        const rets = [];\n        for (let i = 0; i < len; i++) {\n            rets.push(this._type.decodeValue(b, vec._type));\n        }\n        return rets;\n    }\n    get name() {\n        return `vec ${this._type.name}`;\n    }\n    display() {\n        return `vec ${this._type.display()}`;\n    }\n    valueToString(x) {\n        const elements = x.map(e => this._type.valueToString(e));\n        return 'vec {' + elements.join('; ') + '}';\n    }\n}\n/**\n * Represents an IDL Option\n * @param {Type} t\n */\nexport class OptClass extends ConstructType {\n    constructor(_type) {\n        super();\n        this._type = _type;\n    }\n    accept(v, d) {\n        return v.visitOpt(this, this._type, d);\n    }\n    covariant(x) {\n        return Array.isArray(x) && (x.length === 0 || (x.length === 1 && this._type.covariant(x[0])));\n    }\n    encodeValue(x) {\n        if (x.length === 0) {\n            return Buffer.from([0]);\n        }\n        else {\n            return Buffer.concat([Buffer.from([1]), this._type.encodeValue(x[0])]);\n        }\n    }\n    _buildTypeTableImpl(typeTable) {\n        this._type.buildTypeTable(typeTable);\n        const opCode = slebEncode(-18 /* Opt */);\n        const buffer = this._type.encodeType(typeTable);\n        typeTable.add(this, Buffer.concat([opCode, buffer]));\n    }\n    decodeValue(b, t) {\n        const opt = this.checkType(t);\n        if (!(opt instanceof OptClass)) {\n            throw new Error('Not an option type');\n        }\n        const len = safeRead(b, 1).toString('hex');\n        if (len === '00') {\n            return [];\n        }\n        else if (len === '01') {\n            return [this._type.decodeValue(b, opt._type)];\n        }\n        else {\n            throw new Error('Not an option value');\n        }\n    }\n    get name() {\n        return `opt ${this._type.name}`;\n    }\n    display() {\n        return `opt ${this._type.display()}`;\n    }\n    valueToString(x) {\n        if (x.length === 0) {\n            return 'null';\n        }\n        else {\n            return `opt ${this._type.valueToString(x[0])}`;\n        }\n    }\n}\n/**\n * Represents an IDL Record\n * @param {Object} [fields] - mapping of function name to Type\n */\nexport class RecordClass extends ConstructType {\n    constructor(fields = {}) {\n        super();\n        this._fields = Object.entries(fields).sort((a, b) => idlLabelToId(a[0]) - idlLabelToId(b[0]));\n    }\n    accept(v, d) {\n        return v.visitRecord(this, this._fields, d);\n    }\n    tryAsTuple() {\n        const res = [];\n        for (let i = 0; i < this._fields.length; i++) {\n            const [key, type] = this._fields[i];\n            if (key !== `_${i}_`) {\n                return null;\n            }\n            res.push(type);\n        }\n        return res;\n    }\n    covariant(x) {\n        return (typeof x === 'object' &&\n            this._fields.every(([k, t]) => {\n                // eslint-disable-next-line\n                if (!x.hasOwnProperty(k)) {\n                    throw new Error(`Record is missing key \"${k}\".`);\n                }\n                return t.covariant(x[k]);\n            }));\n    }\n    encodeValue(x) {\n        const values = this._fields.map(([key]) => x[key]);\n        const bufs = zipWith(this._fields, values, ([, c], d) => c.encodeValue(d));\n        return Buffer.concat(bufs);\n    }\n    _buildTypeTableImpl(T) {\n        this._fields.forEach(([_, value]) => value.buildTypeTable(T));\n        const opCode = slebEncode(-20 /* Record */);\n        const len = lebEncode(this._fields.length);\n        const fields = this._fields.map(([key, value]) => Buffer.concat([lebEncode(idlLabelToId(key)), value.encodeType(T)]));\n        T.add(this, Buffer.concat([opCode, len, Buffer.concat(fields)]));\n    }\n    decodeValue(b, t) {\n        const record = this.checkType(t);\n        if (!(record instanceof RecordClass)) {\n            throw new Error('Not a record type');\n        }\n        const x = {};\n        let idx = 0;\n        for (const [hash, type] of record._fields) {\n            if (idx >= this._fields.length || idlLabelToId(this._fields[idx][0]) !== idlLabelToId(hash)) {\n                // skip field\n                type.decodeValue(b, type);\n                continue;\n            }\n            const [expectKey, expectType] = this._fields[idx];\n            x[expectKey] = expectType.decodeValue(b, type);\n            idx++;\n        }\n        if (idx < this._fields.length) {\n            throw new Error('Cannot find field ' + this._fields[idx][0]);\n        }\n        return x;\n    }\n    get name() {\n        const fields = this._fields.map(([key, value]) => key + ':' + value.name);\n        return `record {${fields.join('; ')}}`;\n    }\n    display() {\n        const fields = this._fields.map(([key, value]) => key + ':' + value.display());\n        return `record {${fields.join('; ')}}`;\n    }\n    valueToString(x) {\n        const values = this._fields.map(([key]) => x[key]);\n        const fields = zipWith(this._fields, values, ([k, c], d) => k + '=' + c.valueToString(d));\n        return `record {${fields.join('; ')}}`;\n    }\n}\n/**\n * Represents Tuple, a syntactic sugar for Record.\n * @param {Type} components\n */\nexport class TupleClass extends RecordClass {\n    constructor(_components) {\n        const x = {};\n        _components.forEach((e, i) => (x['_' + i + '_'] = e));\n        super(x);\n        this._components = _components;\n    }\n    accept(v, d) {\n        return v.visitTuple(this, this._components, d);\n    }\n    covariant(x) {\n        // `>=` because tuples can be covariant when encoded.\n        return (Array.isArray(x) &&\n            x.length >= this._fields.length &&\n            this._components.every((t, i) => t.covariant(x[i])));\n    }\n    encodeValue(x) {\n        const bufs = zipWith(this._components, x, (c, d) => c.encodeValue(d));\n        return Buffer.concat(bufs);\n    }\n    decodeValue(b, t) {\n        const tuple = this.checkType(t);\n        if (!(tuple instanceof TupleClass)) {\n            throw new Error('not a tuple type');\n        }\n        if (tuple._components.length < this._components.length) {\n            throw new Error('tuple mismatch');\n        }\n        const res = [];\n        for (const [i, wireType] of tuple._components.entries()) {\n            if (i >= this._components.length) {\n                // skip value\n                wireType.decodeValue(b, wireType);\n            }\n            else {\n                res.push(this._components[i].decodeValue(b, wireType));\n            }\n        }\n        return res;\n    }\n    display() {\n        const fields = this._components.map(value => value.display());\n        return `record {${fields.join('; ')}}`;\n    }\n    valueToString(values) {\n        const fields = zipWith(this._components, values, (c, d) => c.valueToString(d));\n        return `record {${fields.join('; ')}}`;\n    }\n}\n/**\n * Represents an IDL Variant\n * @param {Object} [fields] - mapping of function name to Type\n */\nexport class VariantClass extends ConstructType {\n    constructor(fields = {}) {\n        super();\n        this._fields = Object.entries(fields).sort((a, b) => idlLabelToId(a[0]) - idlLabelToId(b[0]));\n    }\n    accept(v, d) {\n        return v.visitVariant(this, this._fields, d);\n    }\n    covariant(x) {\n        return (typeof x === 'object' &&\n            Object.entries(x).length === 1 &&\n            this._fields.every(([k, v]) => {\n                // eslint-disable-next-line\n                return !x.hasOwnProperty(k) || v.covariant(x[k]);\n            }));\n    }\n    encodeValue(x) {\n        for (let i = 0; i < this._fields.length; i++) {\n            const [name, type] = this._fields[i];\n            // eslint-disable-next-line\n            if (x.hasOwnProperty(name)) {\n                const idx = lebEncode(i);\n                const buf = type.encodeValue(x[name]);\n                return Buffer.concat([idx, buf]);\n            }\n        }\n        throw Error('Variant has no data: ' + x);\n    }\n    _buildTypeTableImpl(typeTable) {\n        this._fields.forEach(([, type]) => {\n            type.buildTypeTable(typeTable);\n        });\n        const opCode = slebEncode(-21 /* Variant */);\n        const len = lebEncode(this._fields.length);\n        const fields = this._fields.map(([key, value]) => Buffer.concat([lebEncode(idlLabelToId(key)), value.encodeType(typeTable)]));\n        typeTable.add(this, Buffer.concat([opCode, len, ...fields]));\n    }\n    decodeValue(b, t) {\n        const variant = this.checkType(t);\n        if (!(variant instanceof VariantClass)) {\n            throw new Error('Not a variant type');\n        }\n        const idx = Number(lebDecode(b));\n        if (idx >= variant._fields.length) {\n            throw Error('Invalid variant index: ' + idx);\n        }\n        const [wireHash, wireType] = variant._fields[idx];\n        for (const [key, expectType] of this._fields) {\n            if (idlLabelToId(wireHash) === idlLabelToId(key)) {\n                const value = expectType.decodeValue(b, wireType);\n                return { [key]: value };\n            }\n        }\n        throw new Error('Cannot find field hash ' + wireHash);\n    }\n    get name() {\n        const fields = this._fields.map(([key, type]) => key + ':' + type.name);\n        return `variant {${fields.join('; ')}}`;\n    }\n    display() {\n        const fields = this._fields.map(([key, type]) => key + (type.name === 'null' ? '' : `:${type.display()}`));\n        return `variant {${fields.join('; ')}}`;\n    }\n    valueToString(x) {\n        for (const [name, type] of this._fields) {\n            // eslint-disable-next-line\n            if (x.hasOwnProperty(name)) {\n                const value = type.valueToString(x[name]);\n                if (value === 'null') {\n                    return `variant {${name}}`;\n                }\n                else {\n                    return `variant {${name}=${value}}`;\n                }\n            }\n        }\n        throw new Error('Variant has no data: ' + x);\n    }\n}\n/**\n * Represents a reference to an IDL type, used for defining recursive data\n * types.\n */\nexport class RecClass extends ConstructType {\n    constructor() {\n        super(...arguments);\n        this._id = RecClass._counter++;\n        this._type = undefined;\n    }\n    accept(v, d) {\n        if (!this._type) {\n            throw Error('Recursive type uninitialized.');\n        }\n        return v.visitRec(this, this._type, d);\n    }\n    fill(t) {\n        this._type = t;\n    }\n    getType() {\n        return this._type;\n    }\n    covariant(x) {\n        return this._type ? this._type.covariant(x) : false;\n    }\n    encodeValue(x) {\n        if (!this._type) {\n            throw Error('Recursive type uninitialized.');\n        }\n        return this._type.encodeValue(x);\n    }\n    _buildTypeTableImpl(typeTable) {\n        if (!this._type) {\n            throw Error('Recursive type uninitialized.');\n        }\n        typeTable.add(this, Buffer.alloc(0));\n        this._type.buildTypeTable(typeTable);\n        typeTable.merge(this, this._type.name);\n    }\n    decodeValue(b, t) {\n        if (!this._type) {\n            throw Error('Recursive type uninitialized.');\n        }\n        return this._type.decodeValue(b, t);\n    }\n    get name() {\n        return `rec_${this._id}`;\n    }\n    display() {\n        if (!this._type) {\n            throw Error('Recursive type uninitialized.');\n        }\n        return `μ${this.name}.${this._type.name}`;\n    }\n    valueToString(x) {\n        if (!this._type) {\n            throw Error('Recursive type uninitialized.');\n        }\n        return this._type.valueToString(x);\n    }\n}\nRecClass._counter = 0;\nfunction decodePrincipalId(b) {\n    const x = safeRead(b, 1).toString('hex');\n    if (x !== '01') {\n        throw new Error('Cannot decode principal');\n    }\n    const len = Number(lebDecode(b));\n    const hex = safeRead(b, len).toString('hex').toUpperCase();\n    return PrincipalId.fromHex(hex);\n}\n/**\n * Represents an IDL principal reference\n */\nexport class PrincipalClass extends PrimitiveType {\n    accept(v, d) {\n        return v.visitPrincipal(this, d);\n    }\n    covariant(x) {\n        return x && x._isPrincipal;\n    }\n    encodeValue(x) {\n        const hex = x.toHex();\n        const buf = Buffer.from(hex, 'hex');\n        const len = lebEncode(buf.length);\n        return Buffer.concat([Buffer.from([1]), len, buf]);\n    }\n    encodeType() {\n        return slebEncode(-24 /* Principal */);\n    }\n    decodeValue(b, t) {\n        this.checkType(t);\n        return decodePrincipalId(b);\n    }\n    get name() {\n        return 'principal';\n    }\n    valueToString(x) {\n        return `${this.name} \"${x.toText()}\"`;\n    }\n}\n/**\n * Represents an IDL function reference.\n * @param argTypes Argument types.\n * @param retTypes Return types.\n * @param annotations Function annotations.\n */\nexport class FuncClass extends ConstructType {\n    constructor(argTypes, retTypes, annotations = []) {\n        super();\n        this.argTypes = argTypes;\n        this.retTypes = retTypes;\n        this.annotations = annotations;\n    }\n    static argsToString(types, v) {\n        if (types.length !== v.length) {\n            throw new Error('arity mismatch');\n        }\n        return '(' + types.map((t, i) => t.valueToString(v[i])).join(', ') + ')';\n    }\n    accept(v, d) {\n        return v.visitFunc(this, d);\n    }\n    covariant(x) {\n        return (Array.isArray(x) && x.length === 2 && x[0] && x[0]._isPrincipal && typeof x[1] === 'string');\n    }\n    encodeValue(x) {\n        const hex = x[0].toHex();\n        const buf = Buffer.from(hex, 'hex');\n        const len = lebEncode(buf.length);\n        const canister = Buffer.concat([Buffer.from([1]), len, buf]);\n        const method = Buffer.from(x[1], 'utf8');\n        const methodLen = lebEncode(method.length);\n        return Buffer.concat([Buffer.from([1]), canister, methodLen, method]);\n    }\n    _buildTypeTableImpl(T) {\n        this.argTypes.forEach(arg => arg.buildTypeTable(T));\n        this.retTypes.forEach(arg => arg.buildTypeTable(T));\n        const opCode = slebEncode(-22 /* Func */);\n        const argLen = lebEncode(this.argTypes.length);\n        const args = Buffer.concat(this.argTypes.map(arg => arg.encodeType(T)));\n        const retLen = lebEncode(this.retTypes.length);\n        const rets = Buffer.concat(this.retTypes.map(arg => arg.encodeType(T)));\n        const annLen = lebEncode(this.annotations.length);\n        const anns = Buffer.concat(this.annotations.map(a => this.encodeAnnotation(a)));\n        T.add(this, Buffer.concat([opCode, argLen, args, retLen, rets, annLen, anns]));\n    }\n    decodeValue(b) {\n        const x = safeRead(b, 1).toString('hex');\n        if (x !== '01') {\n            throw new Error('Cannot decode function reference');\n        }\n        const canister = decodePrincipalId(b);\n        const mLen = Number(lebDecode(b));\n        const buf = safeRead(b, mLen);\n        if (!isValidUTF8(buf)) {\n            throw new Error('Not valid UTF8 method name');\n        }\n        const method = buf.toString('utf8');\n        return [canister, method];\n    }\n    get name() {\n        const args = this.argTypes.map(arg => arg.name).join(', ');\n        const rets = this.retTypes.map(arg => arg.name).join(', ');\n        const annon = ' ' + this.annotations.join(' ');\n        return `(${args}) -> (${rets})${annon}`;\n    }\n    valueToString([principal, str]) {\n        return `func \"${principal.toText()}\".${str}`;\n    }\n    display() {\n        const args = this.argTypes.map(arg => arg.display()).join(', ');\n        const rets = this.retTypes.map(arg => arg.display()).join(', ');\n        const annon = ' ' + this.annotations.join(' ');\n        return `(${args}) → (${rets})${annon}`;\n    }\n    encodeAnnotation(ann) {\n        if (ann === 'query') {\n            return Buffer.from([1]);\n        }\n        else if (ann === 'oneway') {\n            return Buffer.from([2]);\n        }\n        else {\n            throw new Error('Illeagal function annotation');\n        }\n    }\n}\nexport class ServiceClass extends ConstructType {\n    constructor(fields) {\n        super();\n        this._fields = Object.entries(fields).sort((a, b) => idlLabelToId(a[0]) - idlLabelToId(b[0]));\n    }\n    accept(v, d) {\n        return v.visitService(this, d);\n    }\n    covariant(x) {\n        return x && x._isPrincipal;\n    }\n    encodeValue(x) {\n        const hex = x.toHex();\n        const buf = Buffer.from(hex, 'hex');\n        const len = lebEncode(buf.length);\n        return Buffer.concat([Buffer.from([1]), len, buf]);\n    }\n    _buildTypeTableImpl(T) {\n        this._fields.forEach(([_, func]) => func.buildTypeTable(T));\n        const opCode = slebEncode(-23 /* Service */);\n        const len = lebEncode(this._fields.length);\n        const meths = this._fields.map(([label, func]) => {\n            const labelBuf = Buffer.from(label, 'utf8');\n            const labelLen = lebEncode(labelBuf.length);\n            return Buffer.concat([labelLen, labelBuf, func.encodeType(T)]);\n        });\n        T.add(this, Buffer.concat([opCode, len, Buffer.concat(meths)]));\n    }\n    decodeValue(b) {\n        return decodePrincipalId(b);\n    }\n    get name() {\n        const fields = this._fields.map(([key, value]) => key + ':' + value.name);\n        return `service {${fields.join('; ')}}`;\n    }\n    valueToString(x) {\n        return `service \"${x.toText()}\"`;\n    }\n}\n/**\n *\n * @param x\n * @returns {string}\n */\nfunction toReadableString(x) {\n    if (typeof x === 'bigint') {\n        return `BigInt(${x})`;\n    }\n    else {\n        return JSON.stringify(x);\n    }\n}\n/**\n * Encode a array of values\n * @returns {Buffer} serialised value\n */\nexport function encode(argTypes, args) {\n    if (args.length < argTypes.length) {\n        throw Error('Wrong number of message arguments');\n    }\n    const typeTable = new TypeTable();\n    argTypes.forEach(t => t.buildTypeTable(typeTable));\n    const magic = Buffer.from(magicNumber, 'utf8');\n    const table = typeTable.encode();\n    const len = lebEncode(args.length);\n    const typs = Buffer.concat(argTypes.map(t => t.encodeType(typeTable)));\n    const vals = Buffer.concat(zipWith(argTypes, args, (t, x) => {\n        if (!t.covariant(x)) {\n            throw new Error(`Invalid ${t.display()} argument: ${toReadableString(x)}`);\n        }\n        return t.encodeValue(x);\n    }));\n    return blobFromBuffer(Buffer.concat([magic, table, len, typs, vals]));\n}\n/**\n * Decode a binary value\n * @param retTypes - Types expected in the buffer.\n * @param bytes - hex-encoded string, or buffer.\n * @returns Value deserialised to JS type\n */\nexport function decode(retTypes, bytes) {\n    const b = new Pipe(bytes);\n    if (bytes.byteLength < magicNumber.length) {\n        throw new Error('Message length smaller than magic number');\n    }\n    const magic = safeRead(b, magicNumber.length).toString();\n    if (magic !== magicNumber) {\n        throw new Error('Wrong magic number: ' + magic);\n    }\n    function readTypeTable(pipe) {\n        const typeTable = [];\n        const len = Number(lebDecode(pipe));\n        for (let i = 0; i < len; i++) {\n            const ty = Number(slebDecode(pipe));\n            switch (ty) {\n                case -18 /* Opt */:\n                case -19 /* Vector */: {\n                    const t = Number(slebDecode(pipe));\n                    typeTable.push([ty, t]);\n                    break;\n                }\n                case -20 /* Record */:\n                case -21 /* Variant */: {\n                    const fields = [];\n                    let objectLength = Number(lebDecode(pipe));\n                    let prevHash;\n                    while (objectLength--) {\n                        const hash = Number(lebDecode(pipe));\n                        if (hash >= Math.pow(2, 32)) {\n                            throw new Error('field id out of 32-bit range');\n                        }\n                        if (typeof prevHash === 'number' && prevHash >= hash) {\n                            throw new Error('field id collision or not sorted');\n                        }\n                        prevHash = hash;\n                        const t = Number(slebDecode(pipe));\n                        fields.push([hash, t]);\n                    }\n                    typeTable.push([ty, fields]);\n                    break;\n                }\n                case -22 /* Func */: {\n                    for (let k = 0; k < 2; k++) {\n                        let funcLength = Number(lebDecode(pipe));\n                        while (funcLength--) {\n                            slebDecode(pipe);\n                        }\n                    }\n                    const annLen = Number(lebDecode(pipe));\n                    safeRead(pipe, annLen);\n                    typeTable.push([ty, undefined]);\n                    break;\n                }\n                case -23 /* Service */: {\n                    let servLength = Number(lebDecode(pipe));\n                    while (servLength--) {\n                        const l = Number(lebDecode(pipe));\n                        safeRead(pipe, l);\n                        slebDecode(pipe);\n                    }\n                    typeTable.push([ty, undefined]);\n                    break;\n                }\n                default:\n                    throw new Error('Illegal op_code: ' + ty);\n            }\n        }\n        const rawList = [];\n        const length = Number(lebDecode(pipe));\n        for (let i = 0; i < length; i++) {\n            rawList.push(Number(slebDecode(pipe)));\n        }\n        return [typeTable, rawList];\n    }\n    const [rawTable, rawTypes] = readTypeTable(b);\n    if (rawTypes.length < retTypes.length) {\n        throw new Error('Wrong number of return values');\n    }\n    const table = rawTable.map(_ => Rec());\n    function getType(t) {\n        if (t < -24) {\n            throw new Error('future value not supported');\n        }\n        if (t < 0) {\n            switch (t) {\n                case -1:\n                    return Null;\n                case -2:\n                    return Bool;\n                case -3:\n                    return Nat;\n                case -4:\n                    return Int;\n                case -5:\n                    return Nat8;\n                case -6:\n                    return Nat16;\n                case -7:\n                    return Nat32;\n                case -8:\n                    return Nat64;\n                case -9:\n                    return Int8;\n                case -10:\n                    return Int16;\n                case -11:\n                    return Int32;\n                case -12:\n                    return Int64;\n                case -13:\n                    return Float32;\n                case -14:\n                    return Float64;\n                case -15:\n                    return Text;\n                case -16:\n                    return Reserved;\n                case -17:\n                    return Empty;\n                case -24:\n                    return Principal;\n                default:\n                    throw new Error('Illegal op_code: ' + t);\n            }\n        }\n        if (t >= rawTable.length) {\n            throw new Error('type index out of range');\n        }\n        return table[t];\n    }\n    function buildType(entry) {\n        switch (entry[0]) {\n            case -19 /* Vector */: {\n                const ty = getType(entry[1]);\n                return Vec(ty);\n            }\n            case -18 /* Opt */: {\n                const ty = getType(entry[1]);\n                return Opt(ty);\n            }\n            case -20 /* Record */: {\n                const fields = {};\n                for (const [hash, ty] of entry[1]) {\n                    const name = `_${hash}_`;\n                    fields[name] = getType(ty);\n                }\n                const record = Record(fields);\n                const tuple = record.tryAsTuple();\n                if (Array.isArray(tuple)) {\n                    return Tuple(...tuple);\n                }\n                else {\n                    return record;\n                }\n            }\n            case -21 /* Variant */: {\n                const fields = {};\n                for (const [hash, ty] of entry[1]) {\n                    const name = `_${hash}_`;\n                    fields[name] = getType(ty);\n                }\n                return Variant(fields);\n            }\n            case -22 /* Func */: {\n                return Func([], [], []);\n            }\n            case -23 /* Service */: {\n                return Service({});\n            }\n            default:\n                throw new Error('Illegal op_code: ' + entry[0]);\n        }\n    }\n    rawTable.forEach((entry, i) => {\n        const t = buildType(entry);\n        table[i].fill(t);\n    });\n    const types = rawTypes.map(t => getType(t));\n    const output = retTypes.map((t, i) => {\n        return t.decodeValue(b, types[i]);\n    });\n    // skip unused values\n    for (let ind = retTypes.length; ind < types.length; ind++) {\n        types[ind].decodeValue(b, types[ind]);\n    }\n    if (b.buffer.length > 0) {\n        throw new Error('decode: Left-over bytes');\n    }\n    return output;\n}\n// Export Types instances.\nexport const Empty = new EmptyClass();\nexport const Reserved = new ReservedClass();\nexport const Bool = new BoolClass();\nexport const Null = new NullClass();\nexport const Text = new TextClass();\nexport const Int = new IntClass();\nexport const Nat = new NatClass();\nexport const Float32 = new FloatClass(32);\nexport const Float64 = new FloatClass(64);\nexport const Int8 = new FixedIntClass(8);\nexport const Int16 = new FixedIntClass(16);\nexport const Int32 = new FixedIntClass(32);\nexport const Int64 = new FixedIntClass(64);\nexport const Nat8 = new FixedNatClass(8);\nexport const Nat16 = new FixedNatClass(16);\nexport const Nat32 = new FixedNatClass(32);\nexport const Nat64 = new FixedNatClass(64);\nexport const Principal = new PrincipalClass();\n/**\n *\n * @param types array of any types\n * @returns TupleClass from those types\n */\nexport function Tuple(...types) {\n    return new TupleClass(types);\n}\n/**\n *\n * @param t IDL Type\n * @returns VecClass from that type\n */\nexport function Vec(t) {\n    return new VecClass(t);\n}\n/**\n *\n * @param t IDL Type\n * @returns OptClass of Type\n */\nexport function Opt(t) {\n    return new OptClass(t);\n}\n/**\n *\n * @param t Record of string and IDL Type\n * @returns RecordClass of string and Type\n */\nexport function Record(t) {\n    return new RecordClass(t);\n}\n/**\n *\n * @param fields Record of string and IDL Type\n * @returns VariantClass\n */\nexport function Variant(fields) {\n    return new VariantClass(fields);\n}\n/**\n *\n * @returns new RecClass\n */\nexport function Rec() {\n    return new RecClass();\n}\n/**\n *\n * @param args array of IDL Types\n * @param ret array of IDL Types\n * @param annotations array of strings, [] by default\n * @returns new FuncClass\n */\nexport function Func(args, ret, annotations = []) {\n    return new FuncClass(args, ret, annotations);\n}\n/**\n *\n * @param t Record of string and FuncClass\n * @returns ServiceClass\n */\nexport function Service(t) {\n    return new ServiceClass(t);\n}\n//# sourceMappingURL=idl.js.map","import { sha256 as jsSha256 } from 'js-sha256';\nimport borc from 'borc';\nimport { Buffer } from 'buffer/';\nimport { blobFromBuffer, blobFromUint8Array, blobToHex, lebEncode, } from '@dfinity/candid';\nimport { Principal } from '@dfinity/principal';\n/**\n * get RequestId as hex-encoded blob.\n * @param requestId - RequestId to hex\n */\nexport function toHex(requestId) {\n    return blobToHex(requestId);\n}\n/**\n * sha256 hash the provided Buffer\n * @param data - input to hash function\n */\nexport function hash(data) {\n    const hashed = jsSha256.create().update(data).arrayBuffer();\n    return blobFromUint8Array(new Uint8Array(hashed));\n}\nfunction hashValue(value) {\n    if (value instanceof borc.Tagged) {\n        return hashValue(value.value);\n    }\n    else if (typeof value === 'string') {\n        return hashString(value);\n    }\n    else if (typeof value === 'number') {\n        return hash(lebEncode(value));\n    }\n    else if (Buffer.isBuffer(value)) {\n        return hash(blobFromUint8Array(new Uint8Array(value)));\n    }\n    else if (value instanceof Uint8Array || value instanceof ArrayBuffer) {\n        return hash(blobFromUint8Array(new Uint8Array(value)));\n    }\n    else if (Array.isArray(value)) {\n        const vals = value.map(hashValue);\n        return hash(Buffer.concat(vals));\n    }\n    else if (value instanceof Principal) {\n        return hash(blobFromUint8Array(value.toUint8Array()));\n    }\n    else if (typeof value === 'object' &&\n        value !== null &&\n        typeof value.toHash === 'function') {\n        return hashValue(value.toHash());\n        // TODO This should be move to a specific async method as the webauthn flow required\n        // the flow to be synchronous to ensure Safari touch id works.\n        // } else if (value instanceof Promise) {\n        //   return value.then(x => hashValue(x));\n    }\n    else if (typeof value === 'bigint') {\n        // Do this check much later than the other bigint check because this one is much less\n        // type-safe.\n        // So we want to try all the high-assurance type guards before this 'probable' one.\n        return hash(lebEncode(value));\n    }\n    throw Object.assign(new Error(`Attempt to hash a value of unsupported type: ${value}`), {\n        // include so logs/callers can understand the confusing value.\n        // (when stringified in error message, prototype info is lost)\n        value,\n    });\n}\nconst hashString = (value) => {\n    const encoder = new TextEncoder();\n    const encoded = encoder.encode(value);\n    return hash(Buffer.from(encoded));\n};\n/**\n * Concatenate many blobs.\n * @param bs - blobs to concatenate\n */\nfunction concat(bs) {\n    return blobFromBuffer(Buffer.concat(bs));\n}\n/**\n * Get the RequestId of the provided ic-ref request.\n * RequestId is the result of the representation-independent-hash function.\n * https://sdk.dfinity.org/docs/interface-spec/index.html#hash-of-map\n * @param request - ic-ref request to hash into RequestId\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function requestIdOf(request) {\n    const hashed = Object.entries(request)\n        .filter(([, value]) => value !== undefined)\n        .map(([key, value]) => {\n        const hashedKey = hashString(key);\n        const hashedValue = hashValue(value);\n        return [hashedKey, hashedValue];\n    });\n    const traversed = hashed;\n    const sorted = traversed.sort(([k1], [k2]) => {\n        return Buffer.compare(Buffer.from(k1), Buffer.from(k2));\n    });\n    const concatenated = concat(sorted.map(concat));\n    const requestId = hash(concatenated);\n    return requestId;\n}\n//# sourceMappingURL=request_id.js.map","var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { Buffer } from 'buffer/';\nimport { Principal } from '@dfinity/principal';\nimport { requestIdOf } from './request_id';\nimport { blobFromBuffer } from '@dfinity/candid';\nconst domainSeparator = Buffer.from(new TextEncoder().encode('\\x0Aic-request'));\n/**\n * An Identity that can sign blobs.\n */\nexport class SignIdentity {\n    /**\n     * Get the principal represented by this identity. Normally should be a\n     * `Principal.selfAuthenticating()`.\n     */\n    getPrincipal() {\n        if (!this._principal) {\n            this._principal = Principal.selfAuthenticating(this.getPublicKey().toDer());\n        }\n        return this._principal;\n    }\n    /**\n     * Transform a request into a signed version of the request. This is done last\n     * after the transforms on the body of a request. The returned object can be\n     * anything, but must be serializable to CBOR.\n     * @param request - internet computer request to transform\n     */\n    async transformRequest(request) {\n        const { body } = request, fields = __rest(request, [\"body\"]);\n        const requestId = await requestIdOf(body);\n        return Object.assign(Object.assign({}, fields), { body: {\n                content: body,\n                sender_pubkey: this.getPublicKey().toDer(),\n                sender_sig: await this.sign(blobFromBuffer(Buffer.concat([domainSeparator, requestId]))),\n            } });\n    }\n}\nexport class AnonymousIdentity {\n    getPrincipal() {\n        return Principal.anonymous();\n    }\n    async transformRequest(request) {\n        return Object.assign(Object.assign({}, request), { body: { content: request.body } });\n    }\n}\n/**\n * Create an IdentityDescriptor from a @dfinity/authentication Identity\n * @param identity - identity describe in returned descriptor\n */\nexport function createIdentityDescriptor(identity) {\n    const identityIndicator = 'getPublicKey' in identity\n        ? { type: 'PublicKeyIdentity', publicKey: identity.getPublicKey().toDer().toString('hex') }\n        : { type: 'AnonymousIdentity' };\n    return identityIndicator;\n}\n/**\n * Type Guard for whether the unknown value is an IdentityDescriptor or not.\n * @param value - value to type guard\n */\nexport function isIdentityDescriptor(value) {\n    var _a, _b;\n    switch ((_a = value) === null || _a === void 0 ? void 0 : _a.type) {\n        case 'AnonymousIdentity':\n            return true;\n        case 'PublicKeyIdentity':\n            if (typeof ((_b = value) === null || _b === void 0 ? void 0 : _b.publicKey) !== 'string') {\n                return false;\n            }\n            return true;\n    }\n    return false;\n}\n//# sourceMappingURL=auth.js.map","// tslint:disable:max-classes-per-file\n// This file is based on:\n// tslint:disable-next-line: max-line-length\n// https://github.com/dfinity-lab/dfinity/blob/9bca65f8edd65701ea6bdb00e0752f9186bbc893/docs/spec/public/index.adoc#cbor-encoding-of-requests-and-responses\nimport borc from 'borc';\nimport { Buffer } from 'buffer/';\nimport * as cbor from 'simple-cbor';\nimport { SelfDescribeCborSerializer } from 'simple-cbor';\nimport { blobFromBuffer, blobFromHex } from '@dfinity/candid';\n// We are using hansl/simple-cbor for CBOR serialization, to avoid issues with\n// encoding the uint64 values that the HTTP handler of the client expects for\n// canister IDs. However, simple-cbor does not yet provide deserialization so\n// we are using `Uint8Array` so that we can use the dignifiedquire/borc CBOR\n// decoder.\nclass PrincipalEncoder {\n    get name() {\n        return 'Principal';\n    }\n    get priority() {\n        return 0;\n    }\n    match(value) {\n        return value && value._isPrincipal === true;\n    }\n    encode(v) {\n        return cbor.value.bytes(v.toUint8Array().buffer);\n    }\n}\nclass BufferEncoder {\n    get name() {\n        return 'Buffer';\n    }\n    get priority() {\n        return 1;\n    }\n    match(value) {\n        return Buffer.isBuffer(value);\n    }\n    encode(v) {\n        return cbor.value.bytes(new Uint8Array(v));\n    }\n}\nclass BigIntEncoder {\n    get name() {\n        return 'BigInt';\n    }\n    get priority() {\n        return 1;\n    }\n    match(value) {\n        return typeof value === `bigint`;\n    }\n    encode(v) {\n        // Always use a bigint encoding.\n        if (v > BigInt(0)) {\n            return cbor.value.tagged(2, cbor.value.bytes(blobFromHex(v.toString(16))));\n        }\n        else {\n            return cbor.value.tagged(3, cbor.value.bytes(blobFromHex((BigInt('-1') * v).toString(16))));\n        }\n    }\n}\nconst serializer = SelfDescribeCborSerializer.withDefaultEncoders(true);\nserializer.addEncoder(new PrincipalEncoder());\nserializer.addEncoder(new BufferEncoder());\nserializer.addEncoder(new BigIntEncoder());\nexport var CborTag;\n(function (CborTag) {\n    CborTag[CborTag[\"Uint64LittleEndian\"] = 71] = \"Uint64LittleEndian\";\n    CborTag[CborTag[\"Semantic\"] = 55799] = \"Semantic\";\n})(CborTag || (CborTag = {}));\nexport const encode = (value) => {\n    return blobFromBuffer(Buffer.from(serializer.serialize(value)));\n};\nfunction decodePositiveBigInt(buf) {\n    const len = buf.byteLength;\n    let res = BigInt(0);\n    for (let i = 0; i < len; i++) {\n        // tslint:disable-next-line:no-bitwise\n        res = res * BigInt(0x100) + BigInt(buf[i]);\n    }\n    return res;\n}\nexport function decode(input) {\n    const decoder = new borc.Decoder({\n        size: input.byteLength,\n        tags: {\n            // Override tags 2 and 3 for BigInt support (borc supports only BigNumber).\n            2: val => decodePositiveBigInt(val),\n            3: val => -decodePositiveBigInt(val),\n            [CborTag.Semantic]: (value) => value,\n        },\n    });\n    const result = decoder.decodeFirst(input);\n    return result;\n}\n//# sourceMappingURL=cbor.js.map","import * as cbor from 'simple-cbor';\nimport { makeNonce, lebEncode } from '@dfinity/candid';\nconst NANOSECONDS_PER_MILLISECONDS = BigInt(1000000);\nconst REPLICA_PERMITTED_DRIFT_MILLISECONDS = BigInt(60 * 1000);\nexport class Expiry {\n    constructor(deltaInMSec) {\n        // Use bigint because it can overflow the maximum number allowed in a double float.\n        this._value =\n            (BigInt(Date.now()) + BigInt(deltaInMSec) - REPLICA_PERMITTED_DRIFT_MILLISECONDS) *\n                NANOSECONDS_PER_MILLISECONDS;\n    }\n    toCBOR() {\n        // TODO: change this to take the minimum amount of space (it always takes 8 bytes now).\n        return cbor.value.u64(this._value.toString(16), 16);\n    }\n    toHash() {\n        return lebEncode(this._value);\n    }\n}\n/**\n * Create a Nonce transform, which takes a function that returns a Buffer, and adds it\n * as the nonce to every call requests.\n * @param nonceFn A function that returns a buffer. By default uses a semi-random method.\n */\nexport function makeNonceTransform(nonceFn = makeNonce) {\n    return async (request) => {\n        // Nonce are only useful for async calls, to prevent replay attacks. Other types of\n        // calls don't need Nonce so we just skip creating one.\n        if (request.endpoint === \"call\" /* Call */) {\n            request.body.nonce = nonceFn();\n        }\n    };\n}\n/**\n * Create a transform that adds a delay (by default 5 minutes) to the expiry.\n *\n * @param delayInMilliseconds The delay to add to the call time, in milliseconds.\n */\nexport function makeExpiryTransform(delayInMilliseconds) {\n    return async (request) => {\n        request.body.ingress_expiry = new Expiry(delayInMilliseconds);\n    };\n}\n//# sourceMappingURL=transforms.js.map","// tslint:enable:camel-case\n// The types of values allowed in the `request_type` field for submit requests.\nexport var SubmitRequestType;\n(function (SubmitRequestType) {\n    SubmitRequestType[\"Call\"] = \"call\";\n})(SubmitRequestType || (SubmitRequestType = {}));\n//# sourceMappingURL=types.js.map","import { Buffer } from 'buffer/';\nimport { AnonymousIdentity } from '../../auth';\nimport * as cbor from '../../cbor';\nimport { Principal } from '@dfinity/principal';\nimport { requestIdOf } from '../../request_id';\nimport { blobFromHex, blobFromUint8Array } from '@dfinity/candid';\nimport { Expiry } from './transforms';\nimport { SubmitRequestType, } from './types';\nexport * from './transforms';\nexport var RequestStatusResponseStatus;\n(function (RequestStatusResponseStatus) {\n    RequestStatusResponseStatus[\"Received\"] = \"received\";\n    RequestStatusResponseStatus[\"Processing\"] = \"processing\";\n    RequestStatusResponseStatus[\"Replied\"] = \"replied\";\n    RequestStatusResponseStatus[\"Rejected\"] = \"rejected\";\n    RequestStatusResponseStatus[\"Unknown\"] = \"unknown\";\n    RequestStatusResponseStatus[\"Done\"] = \"done\";\n})(RequestStatusResponseStatus || (RequestStatusResponseStatus = {}));\n// Default delta for ingress expiry is 5 minutes.\nconst DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS = 5 * 60 * 1000;\n// Root public key for the IC, encoded as hex\nconst IC_ROOT_KEY = '308182301d060d2b0601040182dc7c0503010201060c2b0601040182dc7c05030201036100814' +\n    'c0e6ec71fab583b08bd81373c255c3c371b2e84863c98a4f1e08b74235d14fb5d9c0cd546d968' +\n    '5f913a0c0b2cc5341583bf4b4392e467db96d65b9bb4cb717112f8472e0d5a4d14505ffd7484' +\n    'b01291091c5f87b98883463f98091a0baaae';\nfunction getDefaultFetch() {\n    const result = typeof window === 'undefined'\n        ? typeof global === 'undefined'\n            ? typeof self === 'undefined'\n                ? undefined\n                : self.fetch.bind(self)\n            : global.fetch.bind(global)\n        : window.fetch.bind(window);\n    if (!result) {\n        throw new Error('Could not find default `fetch` implementation.');\n    }\n    return result;\n}\n// A HTTP agent allows users to interact with a client of the internet computer\n// using the available methods. It exposes an API that closely follows the\n// public view of the internet computer, and is not intended to be exposed\n// directly to the majority of users due to its low-level interface.\n//\n// There is a pipeline to apply transformations to the request before sending\n// it to the client. This is to decouple signature, nonce generation and\n// other computations so that this class can stay as simple as possible while\n// allowing extensions.\nexport class HttpAgent {\n    constructor(options = {}) {\n        this._pipeline = [];\n        this._rootKeyFetched = false;\n        this.rootKey = blobFromHex(IC_ROOT_KEY);\n        if (options.source) {\n            if (!(options.source instanceof HttpAgent)) {\n                throw new Error(\"An Agent's source can only be another HttpAgent\");\n            }\n            this._pipeline = [...options.source._pipeline];\n            this._identity = options.source._identity;\n            this._fetch = options.source._fetch;\n            this._host = options.source._host;\n            this._credentials = options.source._credentials;\n        }\n        else {\n            this._fetch = options.fetch || getDefaultFetch() || fetch.bind(global);\n        }\n        if (options.host !== undefined) {\n            if (!options.host.match(/^[a-z]+:/) && typeof window !== 'undefined') {\n                this._host = new URL(window.location.protocol + '//' + options.host);\n            }\n            else {\n                this._host = new URL(options.host);\n            }\n        }\n        else if (options.source !== undefined) {\n            // Safe to ignore here.\n            this._host = options.source._host;\n        }\n        else {\n            const location = typeof window !== 'undefined' ? window.location : undefined;\n            if (!location) {\n                throw new Error('Must specify a host to connect to.');\n            }\n            this._host = new URL(location + '');\n        }\n        if (options.credentials) {\n            const { name, password } = options.credentials;\n            this._credentials = `${name}${password ? ':' + password : ''}`;\n        }\n        this._identity = Promise.resolve(options.identity || new AnonymousIdentity());\n    }\n    addTransform(fn, priority = fn.priority || 0) {\n        // Keep the pipeline sorted at all time, by priority.\n        const i = this._pipeline.findIndex(x => (x.priority || 0) < priority);\n        this._pipeline.splice(i >= 0 ? i : this._pipeline.length, 0, Object.assign(fn, { priority }));\n    }\n    async getPrincipal() {\n        return (await this._identity).getPrincipal();\n    }\n    async call(canisterId, options, identity) {\n        const id = (await (identity !== undefined ? await identity : await this._identity));\n        const canister = Principal.from(canisterId);\n        const ecid = options.effectiveCanisterId\n            ? Principal.from(options.effectiveCanisterId)\n            : canister;\n        const sender = id.getPrincipal() || Principal.anonymous();\n        const submit = {\n            request_type: SubmitRequestType.Call,\n            canister_id: canister,\n            method_name: options.methodName,\n            arg: options.arg,\n            sender: sender,\n            ingress_expiry: new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS),\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        let transformedRequest = (await this._transform({\n            request: {\n                body: null,\n                method: 'POST',\n                headers: Object.assign({ 'Content-Type': 'application/cbor' }, (this._credentials ? { Authorization: 'Basic ' + btoa(this._credentials) } : {})),\n            },\n            endpoint: \"call\" /* Call */,\n            body: submit,\n        }));\n        // Apply transform for identity.\n        transformedRequest = await id.transformRequest(transformedRequest);\n        const body = cbor.encode(transformedRequest.body);\n        // Run both in parallel. The fetch is quite expensive, so we have plenty of time to\n        // calculate the requestId locally.\n        const [response, requestId] = await Promise.all([\n            this._fetch('' + new URL(`/api/v2/canister/${ecid.toText()}/call`, this._host), Object.assign(Object.assign({}, transformedRequest.request), { body })),\n            requestIdOf(submit),\n        ]);\n        if (!response.ok) {\n            throw new Error(`Server returned an error:\\n` +\n                `  Code: ${response.status} (${response.statusText})\\n` +\n                `  Body: ${await response.text()}\\n`);\n        }\n        return {\n            requestId,\n            response: {\n                ok: response.ok,\n                status: response.status,\n                statusText: response.statusText,\n            },\n        };\n    }\n    async query(canisterId, fields, identity) {\n        const id = await (identity !== undefined ? await identity : await this._identity);\n        const canister = typeof canisterId === 'string' ? Principal.fromText(canisterId) : canisterId;\n        const sender = (id === null || id === void 0 ? void 0 : id.getPrincipal()) || Principal.anonymous();\n        const request = {\n            request_type: \"query\" /* Query */,\n            canister_id: canister,\n            method_name: fields.methodName,\n            arg: fields.arg,\n            sender: sender,\n            ingress_expiry: new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS),\n        };\n        // TODO: remove this any. This can be a Signed or UnSigned request.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        let transformedRequest = await this._transform({\n            request: {\n                method: 'POST',\n                headers: Object.assign({ 'Content-Type': 'application/cbor' }, (this._credentials ? { Authorization: 'Basic ' + btoa(this._credentials) } : {})),\n            },\n            endpoint: \"read\" /* Query */,\n            body: request,\n        });\n        // Apply transform for identity.\n        transformedRequest = await id.transformRequest(transformedRequest);\n        const body = cbor.encode(transformedRequest.body);\n        const response = await this._fetch('' + new URL(`/api/v2/canister/${canister.toText()}/query`, this._host), Object.assign(Object.assign({}, transformedRequest.request), { body }));\n        if (!response.ok) {\n            throw new Error(`Server returned an error:\\n` +\n                `  Code: ${response.status} (${response.statusText})\\n` +\n                `  Body: ${await response.text()}\\n`);\n        }\n        return cbor.decode(Buffer.from(await response.arrayBuffer()));\n    }\n    async readState(canisterId, fields, identity) {\n        const canister = typeof canisterId === 'string' ? Principal.fromText(canisterId) : canisterId;\n        const id = await (identity !== undefined ? await identity : await this._identity);\n        const sender = (id === null || id === void 0 ? void 0 : id.getPrincipal()) || Principal.anonymous();\n        // TODO: remove this any. This can be a Signed or UnSigned request.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        let transformedRequest = await this._transform({\n            request: {\n                method: 'POST',\n                headers: Object.assign({ 'Content-Type': 'application/cbor' }, (this._credentials ? { Authorization: 'Basic ' + btoa(this._credentials) } : {})),\n            },\n            endpoint: \"read_state\" /* ReadState */,\n            body: {\n                request_type: \"read_state\" /* ReadState */,\n                paths: fields.paths,\n                sender: sender,\n                ingress_expiry: new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS),\n            },\n        });\n        // Apply transform for identity.\n        transformedRequest = await id.transformRequest(transformedRequest);\n        const body = cbor.encode(transformedRequest.body);\n        const response = await this._fetch('' + new URL(`/api/v2/canister/${canister}/read_state`, this._host), Object.assign(Object.assign({}, transformedRequest.request), { body }));\n        if (!response.ok) {\n            throw new Error(`Server returned an error:\\n` +\n                `  Code: ${response.status} (${response.statusText})\\n` +\n                `  Body: ${await response.text()}\\n`);\n        }\n        return cbor.decode(Buffer.from(await response.arrayBuffer()));\n    }\n    async status() {\n        const headers = this._credentials\n            ? {\n                Authorization: 'Basic ' + btoa(this._credentials),\n            }\n            : {};\n        const response = await this._fetch('' + new URL(`/api/v2/status`, this._host), { headers });\n        if (!response.ok) {\n            throw new Error(`Server returned an error:\\n` +\n                `  Code: ${response.status} (${response.statusText})\\n` +\n                `  Body: ${await response.text()}\\n`);\n        }\n        const buffer = await response.arrayBuffer();\n        return cbor.decode(new Uint8Array(buffer));\n    }\n    async fetchRootKey() {\n        if (!this._rootKeyFetched) {\n            // Hex-encoded version of the replica root key\n            this.rootKey = blobFromUint8Array((await this.status()).root_key);\n            this._rootKeyFetched = true;\n        }\n        return this.rootKey;\n    }\n    _transform(request) {\n        let p = Promise.resolve(request);\n        for (const fn of this._pipeline) {\n            p = p.then(r => fn(r).then(r2 => r2 || r));\n        }\n        return p;\n    }\n}\n//# sourceMappingURL=index.js.map","import { Principal } from '@dfinity/principal';\nexport var ProxyMessageKind;\n(function (ProxyMessageKind) {\n    ProxyMessageKind[\"Error\"] = \"err\";\n    ProxyMessageKind[\"GetPrincipal\"] = \"gp\";\n    ProxyMessageKind[\"GetPrincipalResponse\"] = \"gpr\";\n    ProxyMessageKind[\"Query\"] = \"q\";\n    ProxyMessageKind[\"QueryResponse\"] = \"qr\";\n    ProxyMessageKind[\"Call\"] = \"c\";\n    ProxyMessageKind[\"CallResponse\"] = \"cr\";\n    ProxyMessageKind[\"ReadState\"] = \"rs\";\n    ProxyMessageKind[\"ReadStateResponse\"] = \"rsr\";\n    ProxyMessageKind[\"Status\"] = \"s\";\n    ProxyMessageKind[\"StatusResponse\"] = \"sr\";\n})(ProxyMessageKind || (ProxyMessageKind = {}));\n// A Stub Agent that forwards calls to another Agent implementation.\nexport class ProxyStubAgent {\n    constructor(_frontend, _agent) {\n        this._frontend = _frontend;\n        this._agent = _agent;\n    }\n    onmessage(msg) {\n        switch (msg.type) {\n            case ProxyMessageKind.GetPrincipal:\n                this._agent.getPrincipal().then(response => {\n                    this._frontend({\n                        id: msg.id,\n                        type: ProxyMessageKind.GetPrincipalResponse,\n                        response: response.toText(),\n                    });\n                });\n                break;\n            case ProxyMessageKind.Query:\n                this._agent.query(...msg.args).then(response => {\n                    this._frontend({\n                        id: msg.id,\n                        type: ProxyMessageKind.QueryResponse,\n                        response,\n                    });\n                });\n                break;\n            case ProxyMessageKind.Call:\n                this._agent.call(...msg.args).then(response => {\n                    this._frontend({\n                        id: msg.id,\n                        type: ProxyMessageKind.CallResponse,\n                        response,\n                    });\n                });\n                break;\n            case ProxyMessageKind.ReadState:\n                this._agent.readState(...msg.args).then(response => {\n                    this._frontend({\n                        id: msg.id,\n                        type: ProxyMessageKind.ReadStateResponse,\n                        response,\n                    });\n                });\n                break;\n            case ProxyMessageKind.Status:\n                this._agent.status().then(response => {\n                    this._frontend({\n                        id: msg.id,\n                        type: ProxyMessageKind.StatusResponse,\n                        response,\n                    });\n                });\n                break;\n            default:\n                throw new Error(`Invalid message received: ${JSON.stringify(msg)}`);\n        }\n    }\n}\n// An Agent that forwards calls to a backend. The calls are serialized\nexport class ProxyAgent {\n    constructor(_backend) {\n        this._backend = _backend;\n        this._nextId = 0;\n        this._pendingCalls = new Map();\n        this.rootKey = null;\n    }\n    onmessage(msg) {\n        const id = msg.id;\n        const maybePromise = this._pendingCalls.get(id);\n        if (!maybePromise) {\n            throw new Error('A proxy get the same message twice...');\n        }\n        this._pendingCalls.delete(id);\n        const [resolve, reject] = maybePromise;\n        switch (msg.type) {\n            case ProxyMessageKind.Error:\n                return reject(msg.error);\n            case ProxyMessageKind.GetPrincipalResponse:\n            case ProxyMessageKind.CallResponse:\n            case ProxyMessageKind.QueryResponse:\n            case ProxyMessageKind.ReadStateResponse:\n            case ProxyMessageKind.StatusResponse:\n                return resolve(msg.response);\n            default:\n                throw new Error(`Invalid message being sent to ProxyAgent: ${JSON.stringify(msg)}`);\n        }\n    }\n    async getPrincipal() {\n        return this._sendAndWait({\n            id: this._nextId++,\n            type: ProxyMessageKind.GetPrincipal,\n        }).then(principal => {\n            if (typeof principal !== 'string') {\n                throw new Error('Invalid principal received.');\n            }\n            return Principal.fromText(principal);\n        });\n    }\n    readState(canisterId, fields) {\n        return this._sendAndWait({\n            id: this._nextId++,\n            type: ProxyMessageKind.ReadState,\n            args: [canisterId.toString(), fields],\n        });\n    }\n    call(canisterId, fields) {\n        return this._sendAndWait({\n            id: this._nextId++,\n            type: ProxyMessageKind.Call,\n            args: [canisterId.toString(), fields],\n        });\n    }\n    status() {\n        return this._sendAndWait({\n            id: this._nextId++,\n            type: ProxyMessageKind.Status,\n        });\n    }\n    query(canisterId, fields) {\n        return this._sendAndWait({\n            id: this._nextId++,\n            type: ProxyMessageKind.Query,\n            args: [canisterId.toString(), fields],\n        });\n    }\n    async _sendAndWait(msg) {\n        return new Promise((resolve, reject) => {\n            this._pendingCalls.set(msg.id, [resolve, reject]);\n            this._backend(msg);\n        });\n    }\n    async fetchRootKey() {\n        // Hex-encoded version of the replica root key\n        const rootKey = (await this.status()).root_key;\n        this.rootKey = rootKey;\n        return rootKey;\n    }\n}\n//# sourceMappingURL=proxy.js.map","export * from './api';\nexport * from './http';\nexport * from './proxy';\nexport function getDefaultAgent() {\n    const agent = typeof window === 'undefined'\n        ? typeof global === 'undefined'\n            ? typeof self === 'undefined'\n                ? undefined\n                : self.ic.agent\n            : global.ic.agent\n        : window.ic.agent;\n    if (!agent) {\n        throw new Error('No Agent could be found.');\n    }\n    return agent;\n}\n//# sourceMappingURL=index.js.map","/**\n * This file is generated from the candid for asset management.\n */\n/* tslint:disable */\n// @ts-ignore\nexport default ({ IDL }) => {\n    const canister_id = IDL.Principal;\n    const wasm_module = IDL.Vec(IDL.Nat8);\n    const CanisterSettings = IDL.Record({\n        compute_allocation: IDL.Opt(IDL.Nat),\n        memory_allocation: IDL.Opt(IDL.Nat),\n    });\n    return IDL.Service({\n        provisional_create_canister_with_cycles: IDL.Func([IDL.Record({ amount: IDL.Opt(IDL.Nat), settings: IDL.Opt(CanisterSettings) })], [IDL.Record({ canister_id: canister_id })], []),\n        create_canister: IDL.Func([], [IDL.Record({ canister_id: canister_id })], []),\n        install_code: IDL.Func([\n            IDL.Record({\n                mode: IDL.Variant({ install: IDL.Null, reinstall: IDL.Null, upgrade: IDL.Null }),\n                canister_id: canister_id,\n                wasm_module: wasm_module,\n                arg: IDL.Vec(IDL.Nat8),\n            }),\n        ], [], []),\n        set_controller: IDL.Func([IDL.Record({ canister_id: canister_id, new_controller: IDL.Principal })], [], []),\n    });\n};\n//# sourceMappingURL=management_idl.js.map","import { Actor } from '../actor';\nimport { Principal } from '@dfinity/principal';\nimport managementCanisterIdl from './management_idl';\n/* tslint:enable */\n/**\n * Create a management canister actor.\n * @param config\n */\nexport function getManagementCanister(config) {\n    function transform(methodName, args, callConfig) {\n        const first = args[0];\n        let effectiveCanisterId = Principal.fromHex('');\n        if (first && typeof first === 'object' && first.canister_id) {\n            effectiveCanisterId = Principal.from(first.canister_id);\n        }\n        return { effectiveCanisterId };\n    }\n    return Actor.createActor(managementCanisterIdl, Object.assign(Object.assign(Object.assign({}, config), { canisterId: Principal.fromHex('') }), {\n        callTransform: transform,\n        queryTransform: transform,\n    }));\n}\n//# sourceMappingURL=management.js.map","/**\n * An error that happens in the Agent. This is the root of all errors and should be used\n * everywhere in the Agent code (this package).\n *\n * @todo https://github.com/dfinity/agent-js/issues/420\n */\nexport class AgentError extends Error {\n}\n//# sourceMappingURL=errors.js.map","import * as base64Arraybuffer from 'base64-arraybuffer';\n/* tslint:disable */\n/* eslint-disable */\nlet wasm;\n// This WASM is generated from the BLS Rust code of the Agent RS (see\n// http://github.com/dfinity/agent-rs/)\n// Once the WASM is compiled, simply base64 encode it and include it in this string.\nconst wasmBytesBase64 = `\n    AGFzbQEAAAABXg9gAn9/AGABfwBgA39/fwBgAn9/AX9gAX8Bf2ADf39/AX9gBH9/f38AYAV/f39/fwBgBn9/f39/fwF/\n    YAAAYAZ/f39/f38AYAV/fn5+fgBgAAF/YAF/AX5gAn9/AX4DvAG6AQgEAAEAAAABAgEDAAAMAAACAQEKAQAHBgEAAQEA\n    AgcCAgABAgAGAAgOBAEBBAAAAQALAQkAAwMAAQQBAAICAAIBAQEBAQEGAQACAQEEAAECAQEABQMBAQMEAwQCAwAAAAEA\n    AAAAAAEFAQEAAAACAQIAAQMAAQAGBAACAgMEAAAAAAAGAAQABAQEBAAAAwIAAgACAAEBAAAAAQEBAAEAAAAAAgAAAQAB\n    AQEBAQEBAQEBAQIBAAAAAQ0AAQQFAXABBQUFAwEAEQYJAX8BQYCAwAALBzYEBm1lbW9yeQIACGJsc19pbml0AA0KYmxz\n    X3ZlcmlmeQAnEV9fd2JpbmRnZW5fbWFsbG9jAHwJDQEAQQELBLgBCrkBtwEKiO8CugGXVQIQfwV+IwBB4OEAayIGJABB\n    KxABIgkEQCAJQfSgwABBKxBnIQwDQCAHQStHBEAgByAMaiIJQV9BfyAJLQAAIglBn39qQf8BcUEaSRsgCXE6AAAgB0EB\n    aiEHDAELC0EAIQcgBkGoA2pBOBByGiAGQQE2AuADIAZB6ANqQTgQciEPIAZBoARqQQE2AgAgBkGoBmpBoKfAABBfIAZB\n    qAZqECkhCSAGQbgVakGAAhByGiAGQdjbAGpBgAEQchogBkGbI2pBgQIQciENIAZBsAxqQcAAEHIaIAZByM8AakHAABBy\n    GiAGQdDVAGpBwAAQchogBkEAOgCaIyAGIAlB/wBqIhBBA3ZBAWoiCkEBdCILOgCZIyAGIApBB3Y6AJgjIAtBf2pBBXYi\n    CEEBaiERA0AgB0ErRwRAIAcgDWogByAMai0AADoAACAHQQFqIQcMAQsLIAZBKzoAxiMgBkEgaiAGQZgjakEvQdinwAAQ\n    ggEgBkGwDGpBwAAgAiADIAYoAiAgBigCJBATQQAhDUEAIAtrIRIgBkGZI2ohE0EBIQNBACEJA0ACQCANIAMgEUtyRQRA\n    IAMgCEshDSADIAMgCE1qIQJBACEHA0AgB0EgRgRAIAYgAzoAmCNBACEHA0AgB0ErRwRAIAcgE2ogByAMai0AADoAACAH\n    QQFqIQcMAQsLIAZBKzoAxCMgBkEYaiAGQZgjakEtQeinwAAQggFBACEHIAZByM8AakEAIAZB0NUAakEgIAYoAhggBigC\n    HBATIAkgEmohAyAJIAlBgAIgCUGAAksbIg5rIRQgBkG4FWogCWohFQJAA0AgB0EgRg0FIAcgFGpFDQEgByAVaiAGQcjP\n    AGogB2otAAA6AAAgAyAHQQFqIgdqDQALIAIhAyALIQkMBQsgDkGAAkH4p8AAEDwABSAGQcjPAGogB2oiDiAOLQAAIAZB\n    sAxqIAdqLQAAcyIOOgAAIAZB0NUAaiAHaiAOOgAAIAdBAWohBwwBCwALAAsgEEGACEkhDUEAIQNBACEJA0ACQCAJQQJH\n    BEAgCUEBaiELIAZBuBVqIANqIQJBACEHAkADQCAHIApGBEAgDQRAIAZByM8AakHwABByGiAGQdjbAGohCCAKIQcDQCAH\n    BEAgBkHIzwBqQQgQLiAGIAYpA8hPIAgxAAB8NwPITyAHQX9qIQcgCEEBaiEIDAELCyAGQcjPAGoQRSAGQdDVAGogBkGo\n    BmoQMCAGQZgjakHwABByGiAGQcjPAGogBkHQ1QBqEDZBAEgNBUEAIQIDQCAGQdDVAGpBARAuIAJBAWohAiAGQcjPAGog\n    BkHQ1QBqEDZBf0oNAAsDQCACQQFIDQZBACEHA0AgB0HoAEYEQCAGIAYpA7hWQgGHNwO4VkEAIQcDQCAHQfAARwRAIAZB\n    mCNqIAdqIAZByM8AaiAHaikDADcDACAHQQhqIQcMAQsLIAZBmCNqIAZB0NUAahBkIAZBmCNqEEUgBikDgCRCP4chF0EA\n    IQcDQCAHQfAARwRAIAZByM8AaiAHaiIIIAZBmCNqIAdqKQMAIhYgCCkDAIUgF4MgFoU3AwAgB0EIaiEHDAELCyACQX9q\n    IQIMAgUgBkHQ1QBqIAdqIgggCEEIaikDAEI5hkKAgICAgICAgAKDIAgpAwBCAYeENwMAIAdBCGohBwwBCwALAAsACyAK\n    QYABQaChwAAQPQALIAMgB2oiCEH/AU0EQCAHQYABRg0CIAZB2NsAaiAHaiACIAdqLQAAOgAAIAdBAWohBwwBCwsgCEGA\n    AkGwocAAEDwAC0GAAUGAAUHAocAAEDwACyAGQShqIAZBqANqEAIgBkG4EmogDxACIAZBKGogBkG4EmoQDCAGQegBakHo\n    g8AAEF8CQAJAIAZB6AFqEFoNACAGQShqEIQBDQAgBkGIPWoQS0EAIQcgBkGIwwBqQTgQchogBkG4IWpBOBByGiAGQYjA\n    AGoQSyAGQcjEAGoQSyAGQcjJAGoQSyAGQcjMAGoQSyAGQagGahBLIAZBsAxqEEsgBkHIzwBqEEsgBkHQ1QBqEEsgBkHY\n    2wBqEEsgBkG4FWoQSyAGQZgjaiAGQcjJAGpBwAEQZxogBkHYJGogBkHIzABqQcABEGcaIAZBmCZqIAZBqAZqQcABEGca\n    IAZB2CdqIAZBsAxqQcABEGcaIAZBmClqIAZByM8AakHAARBnGiAGQdgqaiAGQdDVAGpBwAEQZxogBkGYLGogBkHY2wBq\n    QcABEGcaIAZB2C1qIAZBuBVqQcABEGcaIAZBuBVqQecAEHIaIAZBiMAAaiAGQShqEH8gBkGIwABqEBggBkGYI2ogBkEo\n    ahB/A0AgB0HACkYEQCAGQbghaiAGQegBahBrIAYpA7ghIRcgBkG4IWpBARCdASAGQbghahBEIAYpA7ghIRYgBkGIwwBq\n    IAZBuCFqEGsgBkGIwwBqQQEQnQEgBkGIwwBqEEQgBkG4IWogBkGIwwBqIBdCAoGnEE8gBkGIwABqIAZBKGogFkICgacQ\n    bSAGQcjEAGogBkGIwABqEH8gBkG4IWoQKUEDaiIJQQJ2IgdBAWohAkEAIQgCQAJAAkADQAJAIAZBuCFqQQUQjAEhAyAC\n    IAhGBEAgCUGYA0kNASACQecAQbCEwAAQPAALIAhB5wBGDQIgBkG4FWogCGogA0FwaiIDOgAAIAZBuCFqIANBGHRBGHUQ\n    ngEgBkG4IWoQRCAGQbghakEEEDsgCEEBaiEIDAELCyAGQbgVaiACaiADOgAAIANBGHRBGHVBf2oiA0EBdiECIANBD0sN\n    ASAGQYg9aiAGQZgjaiACQcABbGoQfwNAIAdBf0YEQCAGQYg9aiAGQcjEAGoQcyAGQZgjaiAGQYg9akHAARBnGgwICyAH\n    QeYASw0DIAZBiMAAaiAGQZgjaiAGQbgVaiAHaiwAABAfIAdBf2ohByAGQYg9ahAYIAZBiD1qEBggBkGIPWoQGCAGQYg9\n    ahAYIAZBiD1qIAZBiMAAahAMDAALAAtB5wBB5wBBoITAABA8AAsgAkEIQcCEwAAQPAALIAdB5wBB0ITAABA8AAUgBkHI\n    xABqIAZBmCNqIAdqIgIQfyACQcABaiICIAZByMQAahB/IAIgBkGIwABqEAwgB0HAAWohBwwBCwALAAsgBkGYI2oQSwsgB\n    kEoaiAGQZgjahB/IAZBKGoQRyAMEAlBACEHIAZBqAZqQTAQchogBkGwDGpBoKfAABBfAkACQAJAAkACQANAAkAgB0EwRg\n    RAIAYgBi0AqAZBH3E6AKgGIAZByM8AaiAGQagGahBdIAENAUEAQQBB8ILAABA8AAsgASAHRg0CIAZBqAZqIAdqIAAgB2o\n    tAAA6AAAgB0EBaiEHDAELC0EAIQcCQCAALAAAIgJBAE4EQCAAQTBqIQAgAUEwIAFBMEsbQVBqIQIDQCAHQTBGBEAgBkHY\n    2wBqIAZBqAZqEF0gBkHoAWoQSyAGQegBaiAGQcjPAGoQtAEgBkGoAmoiACAGQdjbAGoQtAEgBkHoAmoQaSAGQegBahBEI\n    AZBuBVqIAZB6AFqEE0gBkGYI2ogABCFASAGQZgjahADIAZBmCNqIAZBuBVqEFkNAyAGQegBahCUAQwDCyACIAdGDQQgBk\n    GoBmogB2ogACAHai0AADoAACAHQQFqIQcMAAsACyAGQZgjahBLIAZB0NUAakE4EHIaIAZBATYCiFYgBkGYI2ogBkHIzwB\n    qELQBIAZBmCNqEEQgBkGYJGoQaSAGQdjbAGogBkGYI2oQTQJAIAZB2NsAaiAGQdDVAGoQXEEBRwRAIAZBmCNqEJQBDAEL\n    IAZBuBVqIAZB2NsAaiAGQdDVAGoQIyAGQbgVahBYBEAgBkG4FWoQQSAGQbgVahBECyAGQdgjaiAGQbgVahClAQsgAkEgc\n    UEFdiAGQdgjahBMQQFGRwRAIAZBmCNqEKYBCyAGQegBaiAGQZgjakHAARBnGgsgBkHQPGpB8IHAABBfIAZB6AFqEIQBRQ\n    0CDAMLIAEgAUHggsAAEDwACyAHQTBqIAFBgIPAABA8AAsgBkGoA2oQSyAGQagDaiAGQegBahB/IAZBuBJqEEsgBkG4Emo\n    gBkHoAWoQfyAGQbgSahBHIAZByMcAakHwgcAAEF8gBkGYI2pBqILAABBfIAZBiMMAaiAGQZgjahCLAUEAIQAgBkG4IWpB\n    OBByGiAGQfAhakE4EHIhCSAGQdjbAGpB8IHAABBfIAZBuBVqQYCAwAAQXyAGQZgjakE4EHIaIAZBkCNqIQsgBkGwFWohC\n    gJAAkADQCAAQQdGDQIgAEEBaiEBIAZBuBVqIABBA3RqIQxCACEXQQAhAwNAIANBf2ohByAKIANBA3RqIQIgCyAAIANqQQ\n    N0aiEIA0AgB0EGRgRAIAEhAAwDCyAIQQhqIQggAkEIaiECIAAgB0EBaiIHakEGSw0ACyAAQQZNBEAgB0EGSw0DIAdBAWo\n    hAyAGQQhqIAIpAwAiFiAWQj+HIAwpAwAiFiAWQj+HEDEgCCAGKQMIIhkgF3wiFiAIKQMAIhp8IhhC//////////8DgzcD\n    ACAYIBZUrSAWIBlUrSAGQRBqKQMAIBdCP4d8fCAaQj+HfHxCBoYgGEI6iIQhFwwBCwsLIABBB0G0ncAAEDwACyAHQQdBx\n    J3AABA8AAsgBkG4IWogBkHQPGoQayAGQbghaiAGQZgjahAkIAkgBkHQPGoQayAJIAZBmCNqEBwgCSAGQdjbAGoQYyAGQb\n    gSaiAGQYjDAGoQSCAGQbghahApIQAgBkGIyABqIAZBuCFqIAZByMcAahCNASAGQYjIAGoQKSAASQRAIAZBuCFqIAZBiMg\n    AahBrIAZBqANqEKYBCyAJECkhACAGQYjIAGogCSAGQcjHAGoQjQEgBkGIyABqECkgAEkEQCAJIAZBiMgAahBrIAZBuBJq\n    EKYBCyAGQbghahBEIAkQREEAIQcgBkHIyABqQTgQchogBkGIyQBqQTgQchogBkGYO2pBOBByGiAGQYg9ahBLIAZBiMAAa\n    hBLIAZByMQAahBLIAZByMkAahBLIAZByMwAahBLIAZBqAZqEEsgBkGwDGoQSyAGQcjPAGoQSyAGQdDVAGoQSyAGQdjbAG\n    oQSyAGQbgVahBLIAZBmCNqIAZByMkAakHAARBnGiAGQdgkaiAGQcjMAGpBwAEQZyEAIAZBmCZqIAZBqAZqQcABEGchASA\n    GQdgnaiAGQbAMakHAARBnIQsgBkGYKWogBkHIzwBqQcABEGchCiAGQdgqaiAGQdDVAGpBwAEQZyECIAZBmCxqIAZB2NsA\n    akHAARBnIQMgBkHYLWogBkG4FWpBwAEQZyEIIAZBuBVqQcwBEHIaIAZByMgAaiAGQbghahBrIAZBiMkAaiAJEGsgACAGQ\n    agDahB/IAAgBkG4EmoQcyABIAZBqANqEH8gASAGQbgSahAMIAZBiD1qIAZBuBJqEH8gBkGIPWoQGCAGQcjEAGogABB/IA\n    ZBmCNqIAZByMQAahB/IAZBmCNqIAZBiD1qEHMgBkHIxABqIAEQfyALIAZByMQAahB/IAsgBkGIPWoQDCAGQYjAAGogBkG\n    oA2oQfyAGQYjAAGoQGCAGQcjEAGogABB/IAIgBkHIxABqEH8gAiAGQYjAAGoQDCAGQcjEAGogARB/IAMgBkHIxABqEH8g\n    AyAGQYjAAGoQDCAGQcjEAGogAhB/IAogBkHIxABqEH8gCiAGQYg9ahBzIAZByMQAaiADEH8gCCAGQcjEAGoQfyAIIAZBi\n    D1qEAwgBikDyEghFyAGQcjIAGpBARCdASAGQcjIAGoQRCAGKQPISCEWIAZBmDtqIAZByMgAahBrIAZBmDtqQQEQnQEgBk\n    GYO2oQRCAGQcjIAGogBkGYO2ogF0ICgacQTyAGQYjAAGogBkGoA2ogFkICgacQbSAGQcjEAGogBkGIwABqEH8gBikDiEk\n    hFyAGQYjJAGpBARCdASAGQYjJAGoQRCAGKQOISSEWIAZBmDtqIAZBiMkAahBrIAZBmDtqQQEQnQEgBkGYO2oQRCAGQYjJ\n    AGogBkGYO2ogF0ICgacQTyAGQYg9aiAGQbgSaiAWQgKBpxBtIAZByMQAaiAGQYg9ahAMIAZBmDtqIAZByMgAahBrIAZBm\n    DtqIAZBiMkAahBhIAZBmDtqEEQgBkGYO2oQKUEBaiICQQF2IghBAWohAAJAAkACQAJAA0ACQCAGQcjIAGpBAxCMASEBIA\n    AgB0YEQCAGQYjJAGpBAxCMASEDIAJBlgNJDQEgAEHMAUG0g8AAEDwACyAGQcjIAGogAUF8aiIBEJ4BIAZByMgAahBEIAZ\n    ByMgAakECEDsgBkGIyQBqIAZBiMkAakEDEIwBQXxqIgMQngEgBkGIyQBqEEQgBkGIyQBqQQIQOyAHQcwBRg0CIAZBuBVq\n    IAdqIAMgAUECdGo6AAAgB0EBaiEHDAELCyAGQbgVaiAAaiADIAFBAnRqIgA6AAAgAEEYdEEYdUF/aiIBQQF2IQAgAUEPS\n    w0BIAZBiD1qIAZBmCNqIABBwAFsahB/A0AgCEF/Rg0EIAhBywFLDQMgBkGIwABqIAZBmCNqIAZBuBVqIAhqLAAAEB8gCE\n    F/aiEIIAZBiD1qEBggBkGIPWoQGCAGQYg9aiAGQYjAAGoQDAwACwALQcwBQcwBQaSDwAAQPAALIABBCEHEg8AAEDwACyA\n    IQcwBQdSDwAAQPAALIAZBiD1qIAZByMQAahBzIAZBqANqIAZBiD1qQcABEGcaQX8hByAGQagDahCEAUUNASAGQegBahCm\n    AUEAIQcgBkHIzwBqQeAAEHIaIAUEQANAIAdB4ABGBEAgBiAGLQDIT0EfcToAyE8gBkHQ1QBqIAZByM8AahAhAkACQAJAI\n    AQsAAAiA0F/SgRAIARB4ABqIQAgBUHgACAFQeAASxtBoH9qIQFBACEHA0AgB0HgAEYEQCAGQZgjaiAGQcjPAGoQISAGQa\n    gDaiAGQdDVAGogBkGYI2oQPwwDCyABIAdGDQMgBkHIzwBqIAdqIAAgB2otAAA6AAAgB0EBaiEHDAALAAsgBkGYI2oQKiA\n    GQYjAAGpBOBByGiAGQQE2AsBAIAZBmCNqIAZB0NUAahCQASAGQZgkaiIBELABIAZBmCVqELABIAZBmCNqEKgBIAZB2NsA\n    aiAGQZgjahAmIAZBuBVqIAZB2NsAahBeIAZBuBVqEKYBIAZBuBVqIAZB2NsAahAPIAZBsAxqIAZBuBVqQcAAEGcaAkAgB\n    kGwDGogBkGIwABqEFxBAUcEQCAGQZgjahCYAQwBCyAGQdjbAGoQhwFFBEAgBkHIxABqIAZBmNwAaiIAEIUBIAZByMkAai\n    AGQdjbAGoQhQEgBkHIzABqIAZB2NsAahCFASAGQagGakE4EHIaIAZBATYC4AYgBkGwDGpBOBByGiAGQQE2AugMIAZByMQ\n    AahADIAZByMkAahADIAZByMQAaiAGQcjJAGoQeCAGQcjEAGoQRCAGQbgVaiAGQcjEAGogBkGIwABqECMgBkHIyQBqIAZB\n    uBVqEKUBIAZByMQAaiAGQcjJAGoQpQEgBkHIyQBqIAZB2NsAahClASAGQcjJAGogBkHIxABqEHggBkHIyQBqEEQgBkHIy\n    QBqEEIgBkHIxABqIAAQpQEgBkHIxABqEEIgBkHIyQBqIAZBsAxqEFwhAiAGQcjMAGogBkGwDGoQpQEgBkHIzABqEEEgBk\n    HIzABqEEQgBkGoBmogBkHIyQBqEKUBIAZBqAZqEEEgBkGoBmoQRCAGQcjJAGogBkGoBmpBASACayICEHkgBkGwDGogBkH\n    IzABqIAIQeSAGQbgVaiAGQcjJAGogBkGwDGoQIyAGQdjbAGogBkG4FWoQpQEgBkHIzABqIAZByMkAahClASAGQcjMAGog\n    BkGwDGoQNCAGQcjMAGogBkHY2wBqEEggACAGQcjMAGoQpQEgACAGQcjEAGoQSCAGQagGaiAGQdjbAGoQpQEgBkHY2wBqI\n    AAgAhB5IAAgBkGoBmogAhB5IAZB2NsAahCJASEAIAZBuBVqIAZB2NsAahBeIAZBuBVqEDogBkG4FWoQqAEgBkHY2wBqIA\n    ZBuBVqIAAQjwELIAZB2NsAahCJAQRAIAZB2NsAahA6CyAGQdjbAGoQqwEgASAGQdjbAGoQkAELQQAhAgJAIAEQhwENACA\n    GQdgkahBMIgINACABEEwhAgsgA0EgcUEFdiACQQFGRwRAIAZBmCNqEJwBCyAGQagDaiAGQZgjakGAAxBnGgsgBkHIyABq\n    QfCBwAAQXyAGQagDahCIAQ0FIAZBuBJqECogBkG4FWoQKiAGQdDVAGoQKiAGQdjbAGoQKiAGQZgjahAqIAZBuBhqIAZB0\n    NUAakGAAxBnIQ0gBkG4G2ogBkHY2wBqQYADEGchCSAGQbgeaiAGQZgjakGAAxBnIQAgBkHY2wBqQbiAwAAQXyAGQZgjak\n    HwgMAAEF8gBkGIwwBqIAZB2NsAaiAGQZgjahBJIAZBiMkAakHwgcAAEF9BACEHIAZBuCFqQTgQchogBkHwIWpBqAEQciE\n    DIAZBsAxqQfCBwAAQXyAGQcjPAGpBgIDAABBfIAZB4CJqIQEgBkGoImohDyAGQdDVAGogBkHIyABqEF8DQCAHQagBRg0C\n    IAZBuCFqIAdqIgIgBkHQ1QBqEGsgAiAGQcjPAGoQJCAHQThqIQcgBkHQ1QBqIAZByM8AahAcDAALAAsgB0HgAGogBUGwp\n    MAAEDwACyABIAZB0NUAahBrQQAhByAGQdjbAGpBOBByGiAGQZgjaiADIAZBsAxqEI0BIAZB2NsAaiAGQZgjahBrIAMgBk\n    HY2wBqEGsgBkGYI2ogASAGQbAMahCNASAGQdjbAGogBkGYI2oQayABIAZB2NsAahBrIAZBiD1qECogBkGIwwBqEEAgBkG\n    IwwBqEKgBIAZBmDtqQTgQchogBkG4FWogBkGoA2oQfgNAIAdBgAlGBEACQCAGQbgVaiECQQAhBwNAIAdB4AFHBEAgBkG4\n    IWogB2oiBBApIQUgBkGYI2ogBCAGQYjJAGoQjQEgBkGYO2ogBkGYI2oQayAGQZg7ahApIAVJBEAgBCAGQZg7ahBrIAIQn\n    AELIAQQRCAHQThqIQcgAkGAA2ohAgwBCwsgBkHIxABqECogBkGIwABqECogBkGYI2oQKiAGQcjJAGoQKiAGQcjMAGoQKi\n    AGQagGahAqIAZBsAxqECogBkHIzwBqECogBkHQ1QBqECogBkHY2wBqECogBkGYJmogBkHIyQBqQYADEGchAiAGQZgpaiA\n    GQcjMAGpBgAMQZyEEIAZBmCxqIAZBqAZqQYADEGchBSAGQZgvaiAGQbAMakGAAxBnIQsgBkGYMmogBkHIzwBqQYADEGch\n    CiAGQZg1aiAGQdDVAGpBgAMQZyEIIAZBmDhqIAZB2NsAakGAAxBnIQxBACEHIAZBqAZqQTgQchogBkGwDGogBkG4IWoQX\n    yAGQcjPAGogAxBfIAZB0NUAaiAPEF8gBkHY2wBqIAEQXyAGQegMaiAGQcjPAGpBOBBnGiAGQaANaiAGQdDVAGpBOBBnGi\n    AGQdgNaiAGQdjbAGpBOBBnGiAGQdDVAGpBlwMQchogBkHY2wBqQZcDEHIaA0AgB0HgAUYEQAJAIAZBmCNqIAZBuBVqEH4\n    gBkHIxABqIAZBmCNqEH4gAiAGQcjEAGoQfiACIA0QCyAEIAZByMQAahB+IAQgCRALIAZByMQAaiACEH4gBSAGQcjEAGoQ\n    fiAFIAkQCyAGQcjEAGogBkGYI2oQfiALIAZByMQAahB+IAsgABALIAZByMQAaiACEH4gCiAGQcjEAGoQfiAKIAAQCyAGQ\n    cjEAGogBBB+IAggBkHIxABqEH4gCCAAEAsgBkHIxABqIAUQfiAMIAZByMQAahB+IAwgABALIAZBsAxqQQEgBikDsAxCAo\n    GnayIFEJ0BIAZBsAxqEEQgBkGoBmoQdEEAIQAgBkGwDGohAgJAAkACQAJAA38gAEEERgR/IAZBqAZqECkiA0GXA08NAiA\n    DQQFqIQkgBkHY2wBqIANqQQE6AAAgBkHY2wBqIQggAwVBACEHA0AgB0E4RwRAIAZBqAZqIAdqIgEgASkDACACIAdqKQMA\n    hDcDACAHQQhqIQcMAQsLIAJBOGohAiAAQQFqIQAMAQsLIQcDQCAHBEAgBkGwDGpBARA7IAggBikDsAxCAoGnQQF0QX9qO\n    gAAIAdBf2ohByAIQQFqIQgMAQsLQQAhBwNAIAcgCUYEQCAGQYjAAGogBkGYI2ogBkHQ1QBqIANqLQAAQRl0QRh1QQFyEC\n    AgA0F/aiEHA0AgB0F/Rg0GIAZBiMAAahAUIAdBlgNLDQUgBkHIxABqIAZBmCNqIAZB2NsAaiAHai0AACAGQdDVAGogB2o\n    tAABBAXRqQRh0QRh1ECAgB0F/aiEHIAZBiMAAaiAGQcjEAGoQCwwACwALIAdBlwNGDQIgB0EBaiEBQQAhACAGQdDVAGog\n    B2oiC0EAOgAAIAZB2NsAaiAHai0AACEKQQEhAkE4IQcDQCAHQeABRgRAIAEhBwwCBSAGQbAMaiAHaiIEKQMAIRcgBEEBE\n    DsgBCAKIBdCAoGnbCIIQRh0QRl1EJ4BIAQQRCALIAAgAiAIbGoiADoAACAHQThqIQcgAkEBdCECDAELAAsACwALIANBlw\n    NBkKXAABA8AAtBlwNBlwNBoKXAABA8AAsgB0GXA0GwpcAAEDwACyAGQcjEAGogBkGIwABqEH4gBkHIzwBqECogBkHIzwB\n    qIAZBuBVqEH4gBkHIzwBqEJwBIAZByMQAaiAGQcjPAGoQCyAGQYjAAGogBkHIxABqIAUQbyAGQbgSaiAGQYjAAGoQfkF/\n    IQcgBkG4EmoQiAFFDQogBkG4EmoQOCAGQbgVakG4gMAAEF8gBkGYI2pB8IDAABBfIAZBmDtqIAZBuBVqIAZBmCNqEEkgB\n    kGYPGpBOBByGiAGQdA8akE4EHIaIAZBiD1qECogBkHoAWoQhAFFBEAgBkEoahCEAQ0BIAZBiMAAahAqIAZBiMAAaiAGQb\n    gSahB+IAZBiMAAahBKIAZBiMMAahBLIAZBiMMAaiAGQegBahB/IAZBiMMAahBHIAZByMQAahAqIAZByMQAaiAGQagDahB\n    +IAZByMQAahBKIAZBuCFqEEsgBkG4IWogBkEoahB/IAZBuCFqEEcgBkGYI2ogBkGIwwBqEIUBIAZByMcAaiAGQZgjahCF\n    ASAGQZgjaiAGQcjDAGoQhQEgBkGIyABqIAZBmCNqEIUBIAZBmCNqIAZBuCFqEIUBIAZByMgAaiAGQZgjahCFASAGQZgja\n    iAGQfghahCFASAGQYjJAGogBkGYI2oQhQEgBkHIyQBqECogBkHIzABqECogBkHQ1QBqEGAgBkHIyQBqIAZBiMAAahB+IA\n    ZByMwAaiAGQcjEAGoQfiAGQbAMahAqIAZBsAxqIAZBiMAAahB+IAZBsAxqEJwBIAZByM8AahAqIAZByM8AaiAGQcjEAGo\n    QfiAGQcjPAGoQnAEgBkHQPGogBkGYPGoQVEF/aiEHA0AgB0EBTQRAIAZB0NUAahCTASAGQagGaiAGQdDVAGpBiAYQZxoM\n    BgsgBkHQ1QBqEBsgBkHY2wBqIAZByMkAaiAGQcjHAGogBkGIyABqEBcgBkG4FWogBkHIzABqIAZByMgAaiAGQYjJAGoQF\n    yAGQdjbAGogBkG4FWoQBiAGQdDVAGogBkHY2wBqEAQCQAJAIAZB0DxqIAdBf2oiBxBXIAZBmDxqIAcQV2tBAWoOAwECAA\n    ILIAZB2NsAaiAGQcjJAGogBkGIwABqIAZByMcAaiAGQYjIAGoQFiAGQZgjaiAGQcjMAGogBkHIxABqIAZByMgAaiAGQYj\n    JAGoQFiAGQdjbAGogBkGYI2oQBiAGQdDVAGogBkHY2wBqEAQMAQsgBkHY2wBqIAZByMkAaiAGQbAMaiAGQcjHAGogBkGI\n    yABqEBYgBkGYI2ogBkHIzABqIAZByM8AaiAGQcjIAGogBkGIyQBqEBYgBkHY2wBqIAZBmCNqEAYgBkHQ1QBqIAZB2NsAa\n    hAEDAALAAsgBkGoBmogBkGoA2ogBkEoahAQDAMLBSAGQbAMaiAHahBEIAdBOGohBwwBCwsgBkGoBmogBkG4EmogBkHoAW\n    oQEAsFIAZBiD1qIAZBuBVqIAdqIgIQfiACQYADaiIEIAZBiD1qEH4gBkGYI2ogBkGIwwBqEF4gBkGYI2oQMiAEEKYBIAJ\n    BgARqIgUQpgEgAkGABWoiAhCmASACEKsBIAQgBkGYI2oQDyAFIAZBmCNqEA8gBSAGQYjDAGoQDyAHQYADaiEHDAELCyAG\n    QbgVakG4gMAAEF8gBkGYI2pB8IDAABBfIAZByMQAaiAGQbgVaiAGQZgjahBJIAZBiMAAakGAgMAAEF8gBkGwDGogBkGoB\n    moQaiAGQcjPAGogBkGwDGoQaiAGQdDVAGogBkHIzwBqEI4BIAZB2NsAaiAGQcjRAGoiARCOASAGQbgVaiAGQcjPAGoQjg\n    EgBkGYI2oQLyAGQcjPAGoQmQEgBkHQ1QBqECIgBkHY2wBqIAZByNMAaiIAEBkgBkHY2wBqEGYgBkHQ1QBqIAZB2NsAahC\n    BASAGQdDVAGoQrAEgBkHY2wBqIAAQkgEgBkHY2wBqECIgBkHY2wBqEGYgBkG4FWogARAZIAZB2NsAaiAGQbgVahCBASAG\n    QdjbAGoQrAEgBkG4FWogARCSASAGQbgVahAiIAZBmCNqIAZByM8AahCSASAGQZgjaiAAEBkgBkG4FWogBkGYI2oQgQEgB\n    kG4FWoQrAEgBkGYI2ogARCSASAGQZgjaiAGQbgVahAZIAZBmCNqEGYgBkHIzwBqIAZB0NUAahAZIAZBmCNqIAZByM8Aah\n    CWASAAIAZB2NsAahAZIAAQZiAGQZgjaiAAEJYBIAZBmCNqEKwBIAZByMkAaiAGQZgjahBeIAZByMwAaiAGQZgkaiICEF4\n    gBkHIyQBqEDIgBkHIzABqEDIgBkHIzABqEFUgBkHIzABqEKgBIAZByMkAaiAGQcjMAGoQfSAGQcjJAGoQQCAGQZgjaiAG\n    QcjJAGoQDyAGQcjJAGoQOiAGQcjJAGoQqAEgAiAGQcjJAGoQDyAGQcjPAGogBkHQ1QBqEJIBIAZByM8AaiAGQZgjahAZI\n    AEgBkHY2wBqEJIBIAEgBkGYI2oQGSAAIAZBuBVqEJIBIAAgBkGYI2oQGSAGQQU2AshVIAZBsAxqEJMBIAZBsAxqIAZByM\n    8AahAOIAZByM8AaiAGQbAMahBsIAZBsAxqIAZByMQAahA3IAZBsAxqIAZByMQAahA3IAZBsAxqIAZByM8AahAOIAZB0NU\n    AaiAGQbAMahBqIAZB0NUAahAaIAZB0NUAaiAGQbAMahAOIAZBmCNqIAZBsAxqIAZBiMAAahAdIAZB2NsAaiAGQZgjahBq\n    IAZB2NsAahCTASAGQbgVaiAGQbAMahBqIAZBuBVqEJMBIAZBsAxqIAZB2NsAahBsIAZBsAxqIAZBuBVqEA4gBkGYI2ogB\n    kGwDGogBkGIwABqEB0gBkHY2wBqIAZBmCNqEGwgBkHY2wBqEJMBIAZBuBVqIAZBsAxqEGwgBkG4FWoQkwEgBkGwDGogBk\n    HY2wBqEGwgBkGwDGogBkG4FWoQDiAGQZgjaiAGQbAMaiAGQYjAAGoQHSAGQdjbAGogBkGYI2oQbCAGQdjbAGoQkwEgBkG\n    4FWogBkGwDGoQbCAGQbgVaiAGQcjEAGoQNyAGQbAMaiAGQdjbAGoQbCAGQbAMaiAGQbgVahAOIAZBmCNqIAZBsAxqIAZB\n    iMAAahAdIAZB2NsAaiAGQZgjahBsIAZBmCNqIAZB2NsAaiAGQYjAAGoQHSAGQdjbAGogBkGYI2oQbCAGQbgVaiAGQbAMa\n    hBsIAZBuBVqIAZByMQAahA3IAZBuBVqIAZByMQAahA3IAZB2NsAaiAGQbgVahAOIAZBuBVqIAZBsAxqEGwgBkG4FWoQkw\n    EgBkGwDGogBkHY2wBqEGwgBkGwDGogBkG4FWoQDiAGQbAMaiAGQdDVAGoQDiAGQbAMahCaASAGQagGaiAGQbAMakGIBhB\n    nGiAGQZgjahBuIAZBqAZqIAZBmCNqEHtFDQMgBkGoB2ogAhB7RQ0DIAZBqAhqEIYBRQ0DQQAhByAGQagKahCGAUUNAwwE\n    CyAFIAdHBEAgBkHIzwBqIAdqIAQgB2otAAA6AAAgB0EBaiEHDAELCyAFIAVBoKTAABA8AAtBAEEAQZCkwAAQPAALQX8hB\n    wsgBkHg4QBqJAAgBw8LQQAhByAGQbAMakE4EHIaA0AgB0E4RwRAIAZBsAxqIAdqIAZByM8AaiAHaikDADcDACAHQQhqIQ\n    cMAQsLIAZBmCNqIAZBsAxqEIsBIAZBqANqIAlBBnRqIAZBmCNqQcAAEGcaIAMgCmohAyALIQkMAAsACyAHIAlqIQkgAiE\n    DDAALAAtBK0EBQaS5wQAoAgAiAEEBIAAbEQAAAAvBKgIIfwF+AkACQAJAAkAgAEH1AU8EQCAAQc3/e08NAiAAQQtqIgBB\n    eHEhBkHYtcEAKAIAIgdFDQFBHyEIQQAgBmshBQJAAkAgBkH///8HTQRAIAZBBiAAQQh2ZyIAa0EfcXZBAXEgAEEBdGtBP\n    mohCAsgCEECdEHkt8EAaigCACIABEAgBkEAQRkgCEEBdmtBH3EgCEEfRht0IQMDQAJAIABBBGooAgBBeHEiBCAGSQ0AIA\n    QgBmsiBCAFTw0AIAAhAiAEIgUNAEEAIQUMAwsgAEEUaigCACIEIAEgBCAAIANBHXZBBHFqQRBqKAIAIgBHGyABIAQbIQE\n    gA0EBdCEDIAANAAsgAQRAIAEhAAwCCyACDQILQQAhAkECIAhBH3F0IgBBACAAa3IgB3EiAEUNAyAAQQAgAGtxaEECdEHk\n    t8EAaigCACIARQ0DCwNAIAAgAiAAQQRqKAIAQXhxIgEgBk8gASAGayIDIAVJcSIEGyECIAMgBSAEGyEFIAAoAhAiAQR/I\n    AEFIABBFGooAgALIgANAAsgAkUNAgtB5LjBACgCACIAIAZPQQAgBSAAIAZrTxsNASACKAIYIQcCQAJAIAIgAigCDCIBRg\n    RAIAJBFEEQIAJBFGoiAygCACIBG2ooAgAiAA0BQQAhAQwCCyACKAIIIgAgATYCDCABIAA2AggMAQsgAyACQRBqIAEbIQM\n    DQCADIQQgACIBQRRqIgMoAgAiAEUEQCABQRBqIQMgASgCECEACyAADQALIARBADYCAAsCQCAHRQ0AAkAgAiACKAIcQQJ0\n    QeS3wQBqIgAoAgBHBEAgB0EQQRQgBygCECACRhtqIAE2AgAgAUUNAgwBCyAAIAE2AgAgAQ0AQdi1wQBB2LXBACgCAEF+I\n    AIoAhx3cTYCAAwBCyABIAc2AhggAigCECIABEAgASAANgIQIAAgATYCGAsgAkEUaigCACIARQ0AIAFBFGogADYCACAAIA\n    E2AhgLAkAgBUEQTwRAIAIgBkEDcjYCBCACIAZqIgcgBUEBcjYCBCAFIAdqIAU2AgAgBUGAAk8EQEEfIQAgB0IANwIQIAV\n    B////B00EQCAFQQYgBUEIdmciAGtBH3F2QQFxIABBAXRrQT5qIQALIAcgADYCHCAAQQJ0QeS3wQBqIQQCQAJAAkACQEHY\n    tcEAKAIAIgNBASAAQR9xdCIBcQRAIAQoAgAiA0EEaigCAEF4cSAFRw0BIAMhAAwCC0HYtcEAIAEgA3I2AgAgBCAHNgIAI\n    AcgBDYCGAwDCyAFQQBBGSAAQQF2a0EfcSAAQR9GG3QhAQNAIAMgAUEddkEEcWpBEGoiBCgCACIARQ0CIAFBAXQhASAAIQ\n    MgAEEEaigCAEF4cSAFRw0ACwsgACgCCCIBIAc2AgwgACAHNgIIIAdBADYCGCAHIAA2AgwgByABNgIIDAQLIAQgBzYCACA\n    HIAM2AhgLIAcgBzYCDCAHIAc2AggMAgsgBUEDdiIBQQN0Qdy1wQBqIQACf0HUtcEAKAIAIgNBASABdCIBcQRAIAAoAggM\n    AQtB1LXBACABIANyNgIAIAALIQUgACAHNgIIIAUgBzYCDCAHIAA2AgwgByAFNgIIDAELIAIgBSAGaiIAQQNyNgIEIAAgA\n    moiACAAKAIEQQFyNgIECyACQQhqDwsCQAJAQdS1wQAoAgAiB0EQIABBC2pBeHEgAEELSRsiBkEDdiIBdiICQQNxRQRAIA\n    ZB5LjBACgCAE0NAyACDQFB2LXBACgCACIARQ0DIABBACAAa3FoQQJ0QeS3wQBqKAIAIgFBBGooAgBBeHEgBmshBSABIQM\n    DQCABKAIQIgBFBEAgAUEUaigCACIARQ0ECyAAQQRqKAIAQXhxIAZrIgIgBSACIAVJIgIbIQUgACADIAIbIQMgACEBDAAL\n    AAsCQCACQX9zQQFxIAFqIgVBA3QiAEHktcEAaigCACIDQQhqIgIoAgAiASAAQdy1wQBqIgBHBEAgASAANgIMIAAgATYCC\n    AwBC0HUtcEAIAdBfiAFd3E2AgALIAMgBUEDdCIAQQNyNgIEIAAgA2oiACAAKAIEQQFyNgIEIAIPCwJAQQIgAXQiAEEAIA\n    BrciACIAF0cSIAQQAgAGtxaCIBQQN0IgBB5LXBAGooAgAiA0EIaiIEKAIAIgIgAEHctcEAaiIARwRAIAIgADYCDCAAIAI\n    2AggMAQtB1LXBACAHQX4gAXdxNgIACyADIAZBA3I2AgQgAyAGaiIFIAFBA3QiACAGayIHQQFyNgIEIAAgA2ogBzYCAEHk\n    uMEAKAIAIgAEQCAAQQN2IgJBA3RB3LXBAGohAEHsuMEAKAIAIQgCf0HUtcEAKAIAIgFBASACQR9xdCICcQRAIAAoAggMA\n    QtB1LXBACABIAJyNgIAIAALIQMgACAINgIIIAMgCDYCDCAIIAA2AgwgCCADNgIIC0HsuMEAIAU2AgBB5LjBACAHNgIAIA\n    QPCyADKAIYIQcCQAJAIAMgAygCDCIBRgRAIANBFEEQIANBFGoiASgCACICG2ooAgAiAA0BQQAhAQwCCyADKAIIIgAgATY\n    CDCABIAA2AggMAQsgASADQRBqIAIbIQIDQCACIQQgACIBQRRqIgIoAgAiAEUEQCABQRBqIQIgASgCECEACyAADQALIARB\n    ADYCAAsgB0UNAyADIAMoAhxBAnRB5LfBAGoiACgCAEcEQCAHQRBBFCAHKAIQIANGG2ogATYCACABRQ0EDAMLIAAgATYCA\n    CABDQJB2LXBAEHYtcEAKAIAQX4gAygCHHdxNgIADAMLAkACQAJAAkACQEHkuMEAKAIAIgEgBkkEQEHouMEAKAIAIgAgBk\n    sNA0EAIQUgBkGvgARqIgJBEHZAACIAQX9GDQYgAEEQdCIDRQ0GQfS4wQAgAkGAgHxxIgVB9LjBACgCAGoiAjYCAEH4uME\n    AQfi4wQAoAgAiACACIAAgAksbNgIAQfC4wQAoAgAiBEUNAUH8uMEAIQADQCAAKAIAIgEgACgCBCICaiADRg0DIAAoAggi\n    AA0ACwwEC0HsuMEAKAIAIQMCfyABIAZrIgJBD00EQEHsuMEAQQA2AgBB5LjBAEEANgIAIAMgAUEDcjYCBCABIANqIgJBB\n    GohACACKAIEQQFyDAELQeS4wQAgAjYCAEHsuMEAIAMgBmoiADYCACAAIAJBAXI2AgQgASADaiACNgIAIANBBGohACAGQQ\n    NyCyEGIAAgBjYCACADQQhqDwtBkLnBACgCACIAQQAgACADTRtFBEBBkLnBACADNgIAC0GUucEAQf8fNgIAQYC5wQAgBTY\n    CAEH8uMEAIAM2AgBB6LXBAEHctcEANgIAQfC1wQBB5LXBADYCAEHktcEAQdy1wQA2AgBB+LXBAEHstcEANgIAQey1wQBB\n    5LXBADYCAEGAtsEAQfS1wQA2AgBB9LXBAEHstcEANgIAQYi2wQBB/LXBADYCAEH8tcEAQfS1wQA2AgBBkLbBAEGEtsEAN\n    gIAQYS2wQBB/LXBADYCAEGYtsEAQYy2wQA2AgBBjLbBAEGEtsEANgIAQaC2wQBBlLbBADYCAEGUtsEAQYy2wQA2AgBBiL\n    nBAEEANgIAQai2wQBBnLbBADYCAEGctsEAQZS2wQA2AgBBpLbBAEGctsEANgIAQbC2wQBBpLbBADYCAEGstsEAQaS2wQA\n    2AgBBuLbBAEGstsEANgIAQbS2wQBBrLbBADYCAEHAtsEAQbS2wQA2AgBBvLbBAEG0tsEANgIAQci2wQBBvLbBADYCAEHE\n    tsEAQby2wQA2AgBB0LbBAEHEtsEANgIAQcy2wQBBxLbBADYCAEHYtsEAQcy2wQA2AgBB1LbBAEHMtsEANgIAQeC2wQBB1\n    LbBADYCAEHctsEAQdS2wQA2AgBB6LbBAEHctsEANgIAQfC2wQBB5LbBADYCAEHktsEAQdy2wQA2AgBB+LbBAEHstsEANg\n    IAQey2wQBB5LbBADYCAEGAt8EAQfS2wQA2AgBB9LbBAEHstsEANgIAQYi3wQBB/LbBADYCAEH8tsEAQfS2wQA2AgBBkLf\n    BAEGEt8EANgIAQYS3wQBB/LbBADYCAEGYt8EAQYy3wQA2AgBBjLfBAEGEt8EANgIAQaC3wQBBlLfBADYCAEGUt8EAQYy3\n    wQA2AgBBqLfBAEGct8EANgIAQZy3wQBBlLfBADYCAEGwt8EAQaS3wQA2AgBBpLfBAEGct8EANgIAQbi3wQBBrLfBADYCA\n    EGst8EAQaS3wQA2AgBBwLfBAEG0t8EANgIAQbS3wQBBrLfBADYCAEHIt8EAQby3wQA2AgBBvLfBAEG0t8EANgIAQdC3wQ\n    BBxLfBADYCAEHEt8EAQby3wQA2AgBB2LfBAEHMt8EANgIAQcy3wQBBxLfBADYCAEHgt8EAQdS3wQA2AgBB1LfBAEHMt8E\n    ANgIAQfC4wQAgAzYCAEHct8EAQdS3wQA2AgBB6LjBACAFQVhqIgA2AgAgAyAAQQFyNgIEIAAgA2pBKDYCBEGMucEAQYCA\n    gAE2AgAMAwsgAEEMaigCACADIARNciABIARLcg0BIAAgAiAFajYCBEHwuMEAQfC4wQAoAgAiA0EPakF4cSIBQXhqNgIAQ\n    ei4wQBB6LjBACgCACAFaiICIAMgAWtqQQhqIgA2AgAgAUF8aiAAQQFyNgIAIAIgA2pBKDYCBEGMucEAQYCAgAE2AgAMAg\n    tB6LjBACAAIAZrIgI2AgBB8LjBAEHwuMEAKAIAIgEgBmoiADYCACAAIAJBAXI2AgQgASAGQQNyNgIEIAFBCGohBQwCC0G\n    QucEAQZC5wQAoAgAiACADIAAgA0kbNgIAIAMgBWohAUH8uMEAIQACQANAIAEgACgCAEcEQCAAKAIIIgANAQwCCwsgAEEM\n    aigCAA0AIAAgAzYCACAAIAAoAgQgBWo2AgQgAyAGQQNyNgIEIAMgBmohBCABIANrIAZrIQYCQAJAIAFB8LjBACgCAEcEQ\n    EHsuMEAKAIAIAFGDQEgAUEEaigCACIAQQNxQQFGBEAgASAAQXhxIgAQFSAAIAZqIQYgACABaiEBCyABIAEoAgRBfnE2Ag\n    QgBCAGQQFyNgIEIAQgBmogBjYCACAGQYACTwRAQR8hBSAEQgA3AhAgBkH///8HTQRAIAZBBiAGQQh2ZyIAa0EfcXZBAXE\n    gAEEBdGtBPmohBQsgBCAFNgIcIAVBAnRB5LfBAGohAQJAAkACQAJAQdi1wQAoAgAiAkEBIAVBH3F0IgBxBEAgASgCACIC\n    QQRqKAIAQXhxIAZHDQEgAiEFDAILQdi1wQAgACACcjYCACABIAQ2AgAgBCABNgIYDAMLIAZBAEEZIAVBAXZrQR9xIAVBH\n    0YbdCEBA0AgAiABQR12QQRxakEQaiIAKAIAIgVFDQIgAUEBdCEBIAUiAkEEaigCAEF4cSAGRw0ACwsgBSgCCCIAIAQ2Ag\n    wgBSAENgIIIARBADYCGCAEIAU2AgwgBCAANgIIDAULIAAgBDYCACAEIAI2AhgLIAQgBDYCDCAEIAQ2AggMAwsgBkEDdiI\n    CQQN0Qdy1wQBqIQACf0HUtcEAKAIAIgFBASACdCICcQRAIAAoAggMAQtB1LXBACABIAJyNgIAIAALIQUgACAENgIIIAUg\n    BDYCDCAEIAA2AgwgBCAFNgIIDAILQfC4wQAgBDYCAEHouMEAQei4wQAoAgAgBmoiADYCACAEIABBAXI2AgQMAQtB7LjBA\n    CAENgIAQeS4wQBB5LjBACgCACAGaiIANgIAIAQgAEEBcjYCBCAAIARqIAA2AgALIANBCGoPC0H8uMEAIQADQAJAIAAoAg\n    AiAiAETQRAIAIgACgCBGoiAiAESw0BCyAAKAIIIQAMAQsLQfC4wQAgAzYCAEHouMEAIAVBWGoiADYCACADIABBAXI2AgQ\n    gACADakEoNgIEQYy5wQBBgICAATYCACAEIAJBYGpBeHFBeGoiACAAIARBEGpJGyIBQRs2AgRB/LjBACkCACEJIAFBEGpB\n    hLnBACkCADcCACABIAk3AghBgLnBACAFNgIAQfy4wQAgAzYCAEGEucEAIAFBCGo2AgBBiLnBAEEANgIAIAFBHGohAANAI\n    ABBBzYCACACIABBBGoiAEsNAAsgASAERg0AIAEgASgCBEF+cTYCBCAEIAEgBGsiBUEBcjYCBCABIAU2AgAgBUGAAk8EQE\n    EfIQAgBEIANwIQIAVB////B00EQCAFQQYgBUEIdmciAGtBH3F2QQFxIABBAXRrQT5qIQALIARBHGogADYCACAAQQJ0QeS\n    3wQBqIQMCQAJAAkACQEHYtcEAKAIAIgFBASAAQR9xdCICcQRAIAMoAgAiAkEEaigCAEF4cSAFRw0BIAIhAAwCC0HYtcEA\n    IAEgAnI2AgAgAyAENgIAIARBGGogAzYCAAwDCyAFQQBBGSAAQQF2a0EfcSAAQR9GG3QhAQNAIAIgAUEddkEEcWpBEGoiA\n    ygCACIARQ0CIAFBAXQhASAAIQIgAEEEaigCAEF4cSAFRw0ACwsgACgCCCICIAQ2AgwgACAENgIIIARBGGpBADYCACAEIA\n    A2AgwgBCACNgIIDAMLIAMgBDYCACAEQRhqIAI2AgALIAQgBDYCDCAEIAQ2AggMAQsgBUEDdiICQQN0Qdy1wQBqIQACf0H\n    UtcEAKAIAIgFBASACdCICcQRAIAAoAggMAQtB1LXBACABIAJyNgIAIAALIQEgACAENgIIIAEgBDYCDCAEIAA2AgwgBCAB\n    NgIIC0EAIQVB6LjBACgCACIAIAZNDQBB6LjBACAAIAZrIgI2AgBB8LjBAEHwuMEAKAIAIgEgBmoiADYCACAAIAJBAXI2A\n    gQgASAGQQNyNgIEIAFBCGoPCyAFDwsgASAHNgIYIAMoAhAiAARAIAEgADYCECAAIAE2AhgLIANBFGooAgAiAEUNACABQR\n    RqIAA2AgAgACABNgIYCwJAIAVBEE8EQCADIAZBA3I2AgQgAyAGaiIEIAVBAXI2AgQgBCAFaiAFNgIAQeS4wQAoAgAiAAR\n    AIABBA3YiAkEDdEHctcEAaiEAQey4wQAoAgAhBwJ/QdS1wQAoAgAiAUEBIAJBH3F0IgJxBEAgACgCCAwBC0HUtcEAIAEg\n    AnI2AgAgAAshAiAAIAc2AgggAiAHNgIMIAcgADYCDCAHIAI2AggLQey4wQAgBDYCAEHkuMEAIAU2AgAMAQsgAyAFIAZqI\n    gBBA3I2AgQgACADaiIAIAAoAgRBAXI2AgQLIANBCGoLtA8BA38jAEGAC2siAiQAIAJBCGoQSyACQcgBakE4EHIaIAJBAT\n    YCgAIgAkGIAmpBOBByGiACQQE2AsACIAJByAJqQTgQchogAkEBNgKAAyACQYgDakE4EHIaIAJBATYCwAMgAkHIA2pBOBB\n    yGiACQQE2AoAEIAJBiARqQQEQigEgAkHIBGpBOBByGiACQQE2AoAFIAJBiAVqQTgQchogAkEBNgLABSACQcgFaiABEIUB\n    IAJBiAZqQTgQchogAkEBNgLABiACQcgGakE4EHIaIAJBATYCgAcgAkGIB2pBOBByGiACQQE2AsAHIAJByAdqQTgQchogA\n    kEBNgKACCACQcgFahBYIQMgAkHICWpB4ITAABBfIAJBiApqIAJByAlqEIsBIAJByAFqIAJBiApqEKUBIAJByAlqQZiFwA\n    AQXyACQYgKaiACQcgJahCLASACQYgCaiACQYgKahClASACQcgFahADIAJByAVqQQsQUiACQYgGaiACQcgFahClASACQYg\n    GaiACQYgEahB4IAJBiAZqEEQgAkGIBmogAkHIBWoQSCACQYgFaiACQcgBahClASACQYgFaiACQYgGahBIIAJBiAZqIAJB\n    iARqEHggAkGIBmoQRCACQYgGaiACQYgCahBIIAJBiAZqEEEgAkGIBmoQRCACQYgDaiACQYgGahClASACQcgDaiACQcgFa\n    hClASACQcgDaiACQYgDahBIIAJByAdqIAJBiANqEKUBIAJByAdqEAMgAkHIBmogAkGIBWoQpQEgAkHIBmoQAyACQYgGai\n    ACQcgBahClASACQYgGaiACQcgGahBIIAJByAdqIAJBiAZqEHggAkHIB2oQRCACQcgHaiACQYgDahBIIAJByAZqIAJBiAV\n    qEEggAkGIBmogAkGIAmoQpQEgAkGIBmogAkHIBmoQSCACQcgHaiACQYgGahB4IAJByAdqEEQgAkGIBmogAkHIB2oQpQEg\n    AkGIBmogAkGIBWoQSCACQYgGaiACQYgHahBcIQQgAkGIBWogAkGIBmoQpQEgAkGIBWogAkGIB2oQNCACQYgFaiACQcgHa\n    hBIIAJBiANqIAJBiAVqEEggAkHIA2ogAkGIBWoQSCACQcgFaiABEEggAkHIBmogAkGIBWoQpQEgAkHIBmoQAyACQYgFai\n    ACQcgGahClASACQYgFaiACQcgFahBIIAJByAVqIAJBiAZqEKUBIAJByAVqQQsQUiACQcgJakHQhcAAEF8gAkGICmogAkH\n    ICWoQiwEgAkHIAmogAkGICmoQpQEgAkHIAmogAkGIB2oQSCACQYgDaiACQcgDakEBIARrIgEQeSACQcgGaiACQYgFaiAB\n    EHkgAkGIBmogAkHIBWogARB5IAJBiAdqIAJByAJqIAEQeSACQYgKaiACQYgGaiACQYgHahAjIAJByARqIAJBiApqEKUBI\n    AJByARqIAJByAZqEEggAkHIBGoQWCEBIAJBiAZqIAJByARqEKUBIAJBiAZqEEEgAkGIBmoQRCACQcgEaiACQYgGaiABIA\n    NzEHkgAkGICmpBiIbAABBfIAJBiAhqIAJBiApqEIsBQTghAQNAIAFBoAVGRQRAIAJBiAhqIAJBiANqEEggAkHICWogAUG\n    IhsAAahBfIAFBOGohASACQYgKaiACQcgJahCLASACQYgGaiACQYgKahClASACQYgIaiACQYgGahB4IAJBiAhqEEQMAQsL\n    IAJByAhqIAJBiANqEIUBIAJByAlqQaiLwAAQXyACQYgKaiACQcgJahCLASACQYgGaiACQYgKahClASACQcgIaiACQYgGa\n    hB4IAJByAhqEERBACEBA0AgAUH4A0ZFBEAgAkHICGogAkGIA2oQSCACQcgJaiABQeCLwABqEF8gAUE4aiEBIAJBiApqIA\n    JByAlqEIsBIAJBiAZqIAJBiApqEKUBIAJByAhqIAJBiAZqEHggAkHICGoQRAwBCwsgAkGICmpB2I/AABBfIAJBiAlqIAJ\n    BiApqEIsBQQAhAQNAIAFByAZGBEACQCACQcgJaiACQYgDahCFASACQcgKakHYlsAAEF8gAkGICmogAkHICmoQiwEgAkGI\n    BmogAkGICmoQpQEgAkHICWogAkGIBmoQeCACQcgJahBEQQAhAQNAIAFBkAZGDQEgAkHICWogAkGIA2oQSCACQcgKaiABQ\n    ZCXwABqEF8gAUE4aiEBIAJBiApqIAJByApqEIsBIAJBiAZqIAJBiApqEKUBIAJByAlqIAJBiAZqEHggAkHICWoQRAwACw\n    ALBSACQYgJaiACQYgDahBIIAJByAlqIAFBkJDAAGoQXyABQThqIQEgAkGICmogAkHICWoQiwEgAkGIBmogAkGICmoQpQE\n    gAkGICWogAkGIBmoQeCACQYgJahBEDAELCyACQYgJaiACQcgEahBIIAJBiAZqIAJBiAhqEKUBIAJBiAZqIAJByAlqEEgg\n    AkEIaiACQYgGahClASACQYgGaiACQYgJahClASACQYgGaiACQcgIahBIIAJByABqIAJBiAZqEKUBIAJBiAZqIAJByAhqE\n    KUBIAJBiAZqIAJByAlqEEggAkGIAWogAkGIBmoQpQEgACACQQhqQcABEGcaIAJBgAtqJAALzQ0CE38IfiMAQYADayIBJA\n    AgADQCOCIUIBR+QoCAgBBaBEAgABASCyABQeABakHoABByGiABQcgBaiAAKQMAIhggGEI/hyIZIBggGRAxIAEgASkDyAE\n    iFEL//////////wODNwPYASABQdABaikDACIXQgaGIBRCOoiEIRUgF0I6iCEaIABBCGoiCyEFIAAhBkEBIQcDQCAHQQZP\n    BEAgAEEYaiEMIABBKGohCyAAQRBqIQcgACkDMCEYQQQhBkEAIQkgAUGgAWohDUEDIQpBAiEIQQchBQJAAkADQCAFQQpLD\n    QIgBiAIIAYgCEsbIQ4gBiAKIAYgCksbQQN0QWhqIQ8gAUGYAWogBUEDdCIQIABqQVBqKQMAIhQgFEI/hyAYIBhCP4ciGR\n    AxIAVBAWoiEUEBdiESIA0pAwAhFyABKQOYASEUIAshAyAHIQQgBUF7aiITIQICQANAIAIgDkcEQCACQQdGDQIgAUGIAWo\n    gBCkDACIWIBZCP4cgAykDACIWIBZCP4cQMSABKQOIASIWIBR8IhQgFlStIAFBkAFqKQMAIBd8fCEXIANBeGohAyAEQQhq\n    IQQgAkEBaiECDAELCyABQdgBaiAQaiAUQgGGIhYgFXwiFUL//////////wODNwMAIAFB+ABqIAAgE0EDdGopAwAiGyAbQ\n    j+HIBggGRAxIBUgFlStIBdCAYYgFEI/iIQgGnx8IhRCOochGiAUQgaGIBVCOoiEIRkgBUECaiEFIAFBgAFqKQMAIRcgAS\n    kDeCEUIAshAyAJIQIDQCACIA9GBEAgAUHYAGogACASQQN0aikDACIVIBVCP4ciFiAVIBYQMSABQdgBaiARQQN0aiAUQgG\n    GIhYgGXwiFSABKQNYfCIZQv//////////A4M3AwAgGSAVVK0gAUHgAGopAwAgFSAWVK0gF0IBhiAUQj+IhCAafHx8fCIU\n    QjqHIRogFEIGhiAZQjqIhCEVIApBAmohCiAJQRBqIQkgCEECaiEIIAZBAWohBiAHQRBqIQcMAwsgAkEgRg0DIAFB6ABqI\n    AIgDGopAwAiFSAVQj+HIAMpAwAiFSAVQj+HEDEgASkDaCIVIBR8IhQgFVStIAFB8ABqKQMAIBd8fCEXIANBeGohAyACQQ\n    hqIQIMAAsACwtBB0EHQbSewAAQPAALQQdBB0HEnsAAEDwACyABQagBaiAAKQMoIhQgFEI/hyAYIBhCP4ciFBAxIAEgFSA\n    BKQOoASIVQgGGIhl8IhdC//////////8DgzcDsAIgAUG4AWogGCAUIBggFBAxIAEgFyAZVK0gAUGwAWopAwBCAYYgFUI/\n    iIQgGnx8IhhCBoYgF0I6iIQiFyABKQO4AXwiFEL//////////wODNwO4AiABIBQgF1StIAFBwAFqKQMAIBhCOod8fEIGh\n    iAUQjqIhDcDwAIgAUHIAmogAUHYAWoQBSAAIAFByAJqEGsgAEECNgI4IAFBgANqJAAPCyABQcgAaiAAIAdBA3QiDGopAw\n    AiFCAUQj+HIBggGRAxIAdBAWoiDUEBdiEOIAFB0ABqKQMAIRcgASkDSCEUIAghAiAGIQMgCiEEIAshCQNAIAJFBEAgAUH\n    YAWogDGogFEIBhiIWIBV8IhVC//////////8DgzcDACABQShqIAAgDUEDdCIMaikDACIbIBtCP4cgGCAZEDEgFSAWVK0g\n    F0IBhiAUQj+IhCAafHwiFEI6hyEaIBRCBoYgFUI6iIQhFiAHQQJqIQkgAUEwaikDACEXQQAhAiABKQMoIRQgBSEDIAshB\n    ANAIAIgCGpFBEAgAUEIaiAAIA5BA3RqKQMAIhUgFUI/hyIbIBUgGxAxIAFB2AFqIAxqIBRCAYYiGyAWfCIVIAEpAwh8Ih\n    ZC//////////8DgzcDACAWIBVUrSABQRBqKQMAIBUgG1StIBdCAYYgFEI/iIQgGnx8fHwiFEI6hyEaIBRCBoYgFkI6iIQ\n    hFSAFQRBqIQUgCEEBaiEIIAZBEGohBiAKQQJqIQogCSEHDAQLIAIgB2oiDUEGTQRAIAFBGGogBCkDACIVIBVCP4cgAykD\n    ACIVIBVCP4cQMSABKQMYIhUgFHwiFCAVVK0gAUEgaikDACAXfHwhFyADQXhqIQMgAkF/aiECIARBCGohBAwBCwsgDUEHQ\n    aSewAAQPAALIARBBk0EQCABQThqIAkpAwAiFiAWQj+HIAMpAwAiFiAWQj+HEDEgASkDOCIWIBR8IhQgFlStIAFBQGspAw\n    AgF3x8IRcgAkF/aiECIANBeGohAyAEQX9qIQQgCUEIaiEJDAELCwsgBEEHQZSewAAQPAAL7wwBBH8jAEHADWsiAiQAAkA\n    gACgCgAYiA0EBRwRAIAEoAoAGIgRBAUYNAQJAAkACQAJAIARBA00EQCADQX5xQQJGDQEgAiAAEI4BIAJBgAJqEC8gAkGA\n    BGoQLyACQYAGahAvIAJBgAhqIAAQjgEgAkGACmoQLyACIAEQGSACQYAIaiAAQYACaiIFEJYBIAJBgAhqEKwBIAJBgAJqI\n    AJBgAhqEJIBIAJBgAJqIAEQGSACQYAIaiAFEJIBIAJBgAhqIABBgARqIgMQlgEgAkGACGoQrAEgAkGABmogAkGACGoQkg\n    EgBEECRg0CIAJBwAxqIAFBgAVqEF4gAkGABmogAkHADGoQogEMAwsgAiAAEI4BIAJBgAJqEC8gAkGABGoQLyACQYAGahA\n    vIAIgARAZAkACQCAEQQRGIgQNACAAKAKABkEERg0AIAJBgARqIABBgAJqEJIBIAJBgARqIAFBgAJqEBkMAQsgAkHADGpB\n    OBByGiACQQE2AvgMIAJBgA1qQTgQchogAkG4DWpBATYCACACQYAIakE4EHIaIAJBATYCuAggAkHACGpBOBByGiACQfgIa\n    kEBNgIAIAJBgApqIABBgANqIgMQXiACQYAIaiACQYAKahCQASACQYAKaiABQYADaiIFEF4gAkGACGogAkGACmoQDyACQc\n    AMahCpASAERQRAIAJBgApqIAMQXiACQcAMaiACQYAKahCQASACQYAKaiABQYACahBeIAJBwAxqIAJBgApqEA8LIAAoAoA\n    GQQRHBEAgAkGACmogAEGAAmoQXiACQcAMaiACQYAKahCQASACQYAKaiAFEF4gAkHADGogAkGACmoQDwsgAkGABGogAkHA\n    DGogAkGACGoQoQEgAkGABGoQZgsgAkGACGogABCOASACQYAKaiABEI4BIAJBgAhqIABBgAJqIgQQlgEgAkGACGoQrAEgA\n    kGACmogAUGAAmoiBRCWASACQYAKahCsASACQYACaiACQYAIahCSASACQYACaiACQYAKahAZIAJBgAhqIAQQkgEgAkGACG\n    ogAEGABGoiAxCWASACQYAIahCsASACQYAKaiAFEJIBIAJBgApqIAFBgARqIgUQlgEgAkGACmoQrAEgAkGABmogAkGACGo\n    QkgEgAkGABmogAkGACmoQGSACQYAIaiACEJIBIAJBgAhqECsgAkGACmogAkGABGoQkgEgAkGACmoQKyACQYACaiACQYAI\n    ahCWASAEIAJBgAJqEJIBIAQgAkGACmoQlgEgAkGABmogAkGACmoQlgEgAkGABGogAkGACGoQlgEgAkGACGogABCSASACQ\n    YAIaiADEJYBIAJBgAhqEKwBIAJBgApqIAEQkgEgAkGACmogBRCWASACQYAKahCsASACQYAIaiACQYAKahAZIAJBgARqIA\n    JBgAhqEJYBIAJBgAhqIAMQkgEgAkGACGogBRAZIAJBgApqIAJBgAhqEJIBIAJBgApqECsgAyACQYAEahCSASADIAJBgAp\n    qEJYBIAJBgAZqIAJBgApqEJYBIAJBgAhqEGYgBCACQYAIahCWAQwDCyAAIAEQBgwECyACQcAMaiABQYAFahBeIAJBgAxq\n    IAJBwAxqQcAAEGcaIAJBgAZqIAJBgAxqEKMBCyACQYAGahBmIAJBgAhqIAIQkgEgAkGACGoQKyACQYACaiACQYAIahCWA\n    SAFIAJBgAJqEJIBIAJBgARqIAJBgAhqEJIBIAJBgAhqIAAQkgEgAkGACGogAxCWASACQYAIahCsASACQYAKaiABEJIBIA\n    JBgApqIAFBgARqEJYBIAJBgApqEKwBIAJBgAhqIAJBgApqEBkgAkGABGogAkGACGoQlgEgAkGACGogAxCSAQJAIARBAkc\n    EQCACQcAMaiABQYAFahBeIAJBgAhqIAJBwAxqEKIBDAELIAJBwAxqIAFBgAVqEF4gAkGADGogAkHADGpBwAAQZxogAkGA\n    CGogAkGADGoQowELIAJBgAhqEGYgAkGACmogAkGACGoQkgEgAkGACmoQKyADIAJBgARqEJIBIAMgAkGACmoQlgEgAkGAB\n    mogAkGACmoQlgEgAkGACGoQZiAFIAJBgAhqEJYBCyACQYAGahCsASACQYAGahBmIAAgAhCSASAAIAJBgAZqEJYBIABBBT\n    YCgAYgABCZAQwBCyAAIAEQbAsgAkHADWokAAuaCQIPfwt+IwBBwAJrIgIkACACQeAAakGgp8AAEF8gAEE4EHIhDCACQZg\n    BakHwABByGiACQZACakEwEHIaIAwQdCACIAEpAwAiFEL9//P/z///+QF+Qv//////////A4MiETcDiAIgAkHQAGogEUIA\n    IAIpA2AiGCAYQj+HIhoQMSAUIAIpA1AiEXwiFiARVK0gAkHYAGopAwAgFEI/h3x8IhRCOocgASkDCCIRQj+HfCARIBRCB\n    oYgFkI6iIQiEXwiEiARVK18IRNBASEDAkADQAJAIANBB0YEQCACQZACaiEJIAJB6ABqIQpBByEEIAJB4ABqIQ0gAkGIAm\n    ohDkEGIQ8MAQsgA0EBdiIAQQFqIQUgCiAAayEGIAkgAEEDdCIHayEAIAdBCGohCCACQUBrIANBA3QiBCACQeAAamopAwA\n    iFiAWQj+HIhQgAikDiAIiESARQj+HEDEgAkHIAGopAwAgEiAVfCIRIBJUrSATIBd8fHwgESACKQNAfCITIBFUrXwhEiAD\n    QQFqIQcDQCADIAVNBEAgAkGIAmogBGogE0L9//P/z///+QF+Qv//////////A4MiETcDACACQTBqIBFCACAYIBoQMSACQ\n    SBqIBFCACAWIBQQMSACQZgBaiADQQR0aiIAIAJBKGopAwAiGzcDCCAAIAIpAyAiGTcDACACKQMwIhEgE3wiFiARVK0gAk\n    E4aikDACASfHwiFEI6hyABIAdBA3RqKQMAIhFCP4d8IBEgFEIGhiAWQjqIhCIRfCISIBFUrXwhEyAVIBl8IhUgGVStIBc\n    gG3x8IRcgCUEIaiEJIApBAWohCiAHIQMMAwsgBkEGSw0DIAJBEGogAkHgAGogCGopAwAgAkHgAGogAGopAwB9IhEgEUI/\n    hyACQYgCaiAAaikDACACQYgCaiAIaikDAH0iESARQj+HEDEgAikDECIRIBN8IhMgEVStIAJBGGopAwAgEnx8IRIgBUEBa\n    iEFIABBeGohACAGQX9qIQYgCEEIaiEIDAALAAsLA0ACQCAEQQ1HBEAgDyAEQQF2IgBrIQUgDiAAQQN0IgtrIRAgDSALay\n    EIIBMgF3wgEiAVfCITIBJUrXwhEiAEQQFqIQdBMCEAIAkhBiAKIQMDQCAAIAtGDQIgBUEGTQRAIAIgAyALaikDACAAIAh\n    qKQMAfSIRIBFCP4cgACAQaikDACAGIAtqKQMAfSIRIBFCP4cQMSACKQMAIhEgE3wiEyARVK0gAkEIaikDACASfHwhEiAF\n    QX9qIQUgBkEIaiEGIANBCGohAyAAQXhqIQAMAQsLIAVBB0HknsAAEDwACyAMIBJC//////////8DgzcDMCACQcACaiQAD\n    wsgBEEDdCAMakFIaiATQv//////////A4M3AwAgEkI6hyABIAdBA3RqKQMAIhFCP4d8IBEgEkIGhiATQjqIhCIRfCISIB\n    FUrXwhEyAXIARBBHQgAmpBOGoiAEEIaikDAH0gFSAAKQMAIhFUrX0hFyAOQQhqIQ4gDUEIaiENIA9BAWohDyAVIBF9IRU\n    gByEEDAALAAsgBkEHQdSewAAQPAAL+QkBBH8jAEGACWsiAiQAIAJBgAhqIAAQXiACIAJBgAhqEF4gAkGACGogAEGAAWoi\n    BBBeIAJBgAFqIAJBgAhqEF4gAkGACGogARBeIAIgAkGACGoQDyACQYAIaiABQYABaiIFEF4gAkGAAWogAkGACGoQDyAAK\n    AKABiEDAkACQCABKAKABkECRwRAIANBAkYNASACQYAIaiAAQYAFahBeIAJBgAJqIAJBgAhqEF4gAkGACGogAUGABWoQXi\n    ACQYACaiACQYAIahAPDAILIANBAkYEQCACQYAIaiAAQYAFahBeIAJBgAdqIAJBgAhqQcAAEGcaIAJBgAZqIAJBgAdqEIU\n    BIAJBgAhqIAFBgAVqEF4gAkGAB2ogAkGACGpBwAAQZxogAkGABmogAkGAB2oQSCACQYAIakE4EHIaIAJBATYCuAggAkHA\n    CGpBOBByIAJB+AhqQQE2AgAgAkGACGogAkGABmoQpQEQsgEgAkGAAmogAkGACGpBgAEQZxoMAgsgAkGACGogAEGABWoQX\n    iACQYACaiACQYAIahBeIAJBgAhqIAFBgAVqEF4gAkGAB2ogAkGACGpBwAAQZxogAkGAAmogAkGAB2oQoAEMAQsgAkGACG\n    ogAUGABWoQXiACQYACaiACQYAIahBeIAJBgAhqIABBgAVqEF4gAkGAB2ogAkGACGpBwAAQZxogAkGAAmogAkGAB2oQoAE\n    LIAJBgAhqIAAQXiACQYADaiACQYAIahBeIAJBgAhqIAEQXiACQYAEaiACQYAIahBeIAJBgAhqIAQQXiACQYADaiACQYAI\n    ahCVASACQYADahCoASACQYAIaiAFEF4gAkGABGogAkGACGoQlQEgAkGABGoQqAEgAkGABWogAkGAA2oQXiACQYAFaiACQ\n    YAEahAPIAJBgAZqIAIQXiACQYAGaiACQYABahCVASACQYAGahA6IAJBgAVqIAJBgAZqEJUBIAJBgAhqIAAQXiACQYADai\n    ACQYAIahCQASACQYAIaiAAQYAFaiIDEF4gAkGAA2ogAkGACGoQlQEgAkGAA2oQqAEgAkGACGogARBeIAJBgARqIAJBgAh\n    qEJABIAJBgAhqIAFBgAVqIgEQXiACQYAEaiACQYAIahCVASACQYAEahCoASACQYAHaiACQYADahBeIAJBgAdqIAJBgARq\n    EA8gAkGABmogAhCQASACQYAGaiACQYACahCVASACQYAGahA6IAJBgAdqIAJBgAZqEJUBIAJBgAhqIAQQXiACQYADaiACQ\n    YAIahCQASACQYAIaiADEF4gAkGAA2ogAkGACGoQlQEgAkGAA2oQqAEgAkGACGogBRBeIAJBgARqIAJBgAhqEJABIAJBgA\n    hqIAEQXiACQYAEaiACQYAIahCVASACQYAEahCoASACQYAIaiACQYADahBeIAJBgAhqIAJBgARqEA8gAkGABmogAkGAAWo\n    QkAEgAkGABmogAkGAAmoQlQEgAkGABmoQOiACQYAIaiACQYAGahCVASACQYABahBVIAIgAkGAAWoQlQEgACACIAJBgAVq\n    EKEBIAJBgAJqEFUgAkGAAmoQqAEgAEGAA2ogAkGAAmoQkAEgAEGAAmoQqQEgAkGACGoQqAEgAkGACGoQVSAAQYAEaiIBI\n    AJBgAhqIAJBgAdqEKEBIAAQrAEgARCsASAAQQQ2AoAGIAJBgAlqJAALnwgBB38jAEGgC2siASQAIAFBCGpBoKfAABBfIA\n    FBCGpBARCeAQNAIAJBMEYEQCABIAEpAzhCAYc3AzggAUEIakEBEJ4BIAFBCGpBARA7QQAhAiABQYABakE4EHIaIAFB4Ap\n    qQTgQchogAUGACWpBOBByGiABQQE2ArgBIAFBwAFqQTgQciEEIAFB+AFqQQE2AgAgAUGAAmpBOBByGiABQbgCakEBNgIA\n    IAFBwAJqQTgQchogAUH4AmpBATYCACABQYADakE4EHIaIAFBuANqQQE2AgAgAUHAA2pBOBByGiABQfgDakEBNgIAIAFBg\n    ARqQTgQchogAUG4BGpBATYCACABQcAEakE4EHIaIAFB+ARqQQE2AgAgAUGABWpBOBByGiABQbgFakEBNgIAIAFBwAVqQT\n    gQchogAUH4BWpBATYCACABQYAGakE4EHIaIAFBuAZqQQE2AgAgAUHABmpBOBByGiABQfgGakEBNgIAIAFBgAdqQTgQcho\n    gAUG4B2pBATYCACABQcAHakE4EHIaIAFB+AdqQQE2AgAgAUGACGogAUHgCmpBOBBnGiABQbgIakEBNgIAIAFBwAhqIAFB\n    gAlqQTgQZxogAUH4CGpBATYCACABQYAJakHnABByGiABQegJaiAAEIUBIAFB6AlqEEQgAUGoCmogAUEIahBfIAFBqApqE\n    EQgAUGoCmoQKUEDaiIFQQJ2IgNBAWohBgJAAkACQAJAAkACQANAAkAgAiAGRgRAIAFBgAFqEGkgBCABQegJahClASABQe\n    AKakE4EHIaIAFBATYCmAtBgHkhAgwBCyABQagKaiABQagKakEEEIwBIgcQngEgAUGoCmoQRCACQecARg0CIAFBgAlqIAJ\n    qIAc6AAAgAUGoCmpBBBA7IAJBAWohAgwBCwsDQCACBEAgAUHgCmogAUGAAWogAmoiBEHAB2oQpQEgBEGACGoiBCABQeAK\n    ahClASAEIAFB6AlqEEggAkFAayECDAELCyAFQZwDTw0BIAFBgAlqIANqLAAAIgJBD0sNAiABQUBrIAFBgAFqIAJBBnRqE\n    IUBIANBf2ohAgNAIAJBf0YNBiABQUBrEAMgAUFAaxADIAFBQGsQAyABQUBrEAMgAkHmAEsNBCABQYAJaiACai0AACIDQQ\n    9LDQUgAUFAayABQYABaiADQQZ0ahBIIAJBf2ohAgwACwALQecAQecAQYSjwAAQPAALIANB5wBBlKPAABA8AAsgAkEQQaS\n    jwAAQPAALIAJB5wBBtKPAABA8AAsgA0EYdEEYdUEQQcSjwAAQPAALIAFBQGsQEiAAIAFBQGsQpQEgAUGgC2okAAUgAUEI\n    aiACaiIDIANBCGopAwBCOYZCgICAgICAgIACgyADKQMAQgGHhDcDACACQQhqIQIMAQsLC8EHAhJ/BX4jAEGQAmsiBCQAI\n    ABB8AAQciEPIARBMGpB4AEQchogBEEwaiEAAkADQCADQThGBEACQCAPIAQpAzAiGEL//////////wODNwMAIAFBCGohCS\n    ACQQhqIQogAiEMIAEhDUF4IRBBASEGIBghFSAEQThqKQMAIhkhFwNAAkAgF0IGhiAVQjqIhCEWIBdCOochFyAGQQdGBEA\n    gAUEIaiEMIAJBCGohDUEHIQBBBiEKDAELIAsgBkEBdiIFayEAIAwgBUEDdCIIayERIA0gCGshEiAEQTBqIAZBBHRqIgVB\n    CGopAwAgGXwgBSkDACIVIBh8IhggFVStfCIZIBd8IBYgGHwiFSAYVK18IRcgCEFQaiETIAggEGohFCAGQQFqIQ5BACEDI\n    AkhByAKIQUDQCADIBRGBEAgDyAGQQN0aiAVQv//////////A4M3AwAgDEEIaiEMIA1BCGohDSALQQFqIQsgEEF4aiEQIA\n    4hBgwDCyADIBNGDQYgAEEGSw0DIARBEGogAyARaikDACAFIAhqKQMAfSIWIBZCP4cgByAIaikDACADIBJqKQMAfSIWIBZ\n    CP4cQMSAEKQMQIhYgFXwiFSAWVK0gBEEYaikDACAXfHwhFyAAQX9qIQAgB0EIaiEHIAVBCGohBSADQXhqIQMMAAsACwsD\n    QAJAIABBDUcEQCAKIABBAXYiBWshByACIAVBA3QiCWshCCABIAlrIQsgGSAAQQR0IARqQUBqIgVBCGopAwB9IBggBSkDA\n    CIVVK19IhkgF3wgGCAVfSIYIBZ8IhcgGFStfCEVIABBAWohBkEwIQMgDCEFIA0hDgNAIAMgCUYNAiAHQQZNBEAgBCADIA\n    hqKQMAIAkgDmopAwB9IhYgFkI/hyAFIAlqKQMAIAMgC2opAwB9IhYgFkI/hxAxIAQpAwAiFiAXfCIXIBZUrSAEQQhqKQM\n    AIBV8fCEVIAdBf2ohByAFQQhqIQUgDkEIaiEOIANBeGohAwwBCwsgB0EHQYSewAAQPAALIA8gFjcDaCAEQZACaiQADwsg\n    DyAAQQN0aiAXQv//////////A4M3AwAgFUIGhiAXQjqIhCEWIAJBCGohAiABQQhqIQEgCkEBaiEKIBVCOochFyAGIQAMA\n    AsACwUgBEEgaiACIANqKQMAIhUgFUI/hyABIANqKQMAIhUgFUI/hxAxIAAgBEEoaikDADcDCCAAIAQpAyA3AwAgAEEQai\n    EAIANBCGohAwwBCwsgAEEHQfSdwAAQPAALQQdBB0HkncAAEDwAC8sIAQV/IABBeGoiASAAQXxqKAIAIgNBeHEiAGohAgJ\n    AAkAgA0EBcQ0AIANBA3FFDQEgASgCACIDIABqIQAgASADayIBQey4wQAoAgBGBEAgAigCBEEDcUEDRw0BQeS4wQAgADYC\n    ACACIAIoAgRBfnE2AgQgASAAQQFyNgIEIAAgAWogADYCAA8LIAEgAxAVCwJAIAJBBGoiBCgCACIDQQJxBEAgBCADQX5xN\n    gIAIAEgAEEBcjYCBCAAIAFqIAA2AgAMAQsCQCACQfC4wQAoAgBHBEBB7LjBACgCACACRg0BIAIgA0F4cSICEBUgASAAIA\n    JqIgBBAXI2AgQgACABaiAANgIAIAFB7LjBACgCAEcNAkHkuMEAIAA2AgAPC0HwuMEAIAE2AgBB6LjBAEHouMEAKAIAIAB\n    qIgA2AgAgASAAQQFyNgIEQey4wQAoAgAgAUYEQEHkuMEAQQA2AgBB7LjBAEEANgIAC0GMucEAKAIAIgIgAE8NAkHwuMEA\n    KAIAIgBFDQICQEHouMEAKAIAIgNBKUkNAEH8uMEAIQEDQCABKAIAIgQgAE0EQCAEIAEoAgRqIABLDQILIAEoAggiAQ0AC\n    wtBlLnBAAJ/Qf8fQYS5wQAoAgAiAEUNABpBACEBA0AgAUEBaiEBIAAoAggiAA0ACyABQf8fIAFB/x9LGws2AgAgAyACTQ\n    0CQYy5wQBBfzYCAA8LQey4wQAgATYCAEHkuMEAQeS4wQAoAgAgAGoiADYCACABIABBAXI2AgQgACABaiAANgIADwtBlLn\n    BAAJ/AkAgAEGAAk8EQEEfIQIgAUIANwIQIABB////B00EQCAAQQYgAEEIdmciAmtBH3F2QQFxIAJBAXRrQT5qIQILIAFB\n    HGogAjYCACACQQJ0QeS3wQBqIQMCQAJAAkACQAJAQdi1wQAoAgAiBEEBIAJBH3F0IgVxBEAgAygCACIDQQRqKAIAQXhxI\n    ABHDQEgAyECDAILQdi1wQAgBCAFcjYCACADIAE2AgAMAwsgAEEAQRkgAkEBdmtBH3EgAkEfRht0IQQDQCADIARBHXZBBH\n    FqQRBqIgUoAgAiAkUNAiAEQQF0IQQgAiEDIAJBBGooAgBBeHEgAEcNAAsLIAIoAggiACABNgIMIAIgATYCCCABQRhqQQA\n    2AgAgASACNgIMIAEgADYCCAwCCyAFIAE2AgALIAFBGGogAzYCACABIAE2AgwgASABNgIIC0GUucEAQZS5wQAoAgBBf2oi\n    ADYCACAADQNBhLnBACgCACIADQFB/x8MAgsgAEEDdiICQQN0Qdy1wQBqIQACf0HUtcEAKAIAIgNBASACdCICcQRAIAAoA\n    ggMAQtB1LXBACACIANyNgIAIAALIQIgACABNgIIIAIgATYCDCABIAA2AgwgASACNgIIDwtBACEBA0AgAUEBaiEBIAAoAg\n    giAA0ACyABQf8fIAFB/x9LGws2AgALC9AHAgp/An4jAEEwayIIJABBJyECAkAgADUCACIMQpDOAFQEQCAMIQ0MAQsDQCA\n    IQQlqIAJqIgBBfGogDEKQzgCAIg1C8LF/fiAMfKciA0H//wNxQeQAbiIEQQF0QeaowABqLwAAOwAAIABBfmogBEGcf2wg\n    A2pB//8DcUEBdEHmqMAAai8AADsAACACQXxqIQIgDEL/wdcvViANIQwNAAsLIA2nIgBB4wBKBEAgAkF+aiICIAhBCWpqI\n    A2nIgNB//8DcUHkAG4iAEGcf2wgA2pB//8DcUEBdEHmqMAAai8AADsAAAsCQCAAQQpOBEAgAkF+aiIFIAhBCWpqIABBAX\n    RB5qjAAGovAAA7AAAMAQsgAkF/aiIFIAhBCWpqIABBMGo6AAALQScgBWshA0EBIQJBK0GAgMQAIAEoAgAiAEEBcSIGGyE\n    EIABBHXRBH3VB9KrAAHEhByAIQQlqIAVqIQUCQCABKAIIQQFHBEAgASAEIAcQUw0BIAEoAhggBSADIAFBHGooAgAoAgwR\n    BQAhAgwBCyABQQxqKAIAIgkgAyAGaiIGTQRAIAEgBCAHEFMNASABKAIYIAUgAyABQRxqKAIAKAIMEQUAIQIMAQsCQAJAA\n    kACQCAAQQhxBEAgASgCBCEKIAFBMDYCBCABLQAgIQsgAUEBOgAgIAEgBCAHEFMNBUEAIQIgCSAGayIAIQRBASABLQAgIg\n    cgB0EDRhtBA3FBAWsOAwIBAgMLQQAhAiAJIAZrIgAhCQJAAkACQEEBIAEtACAiBiAGQQNGG0EDcUEBaw4DAQABAgsgAEE\n    BdiECIABBAWpBAXYhCQwBC0EAIQkgACECCyACQQFqIQIDQCACQX9qIgJFDQQgASgCGCABKAIEIAEoAhwoAhARAwBFDQAL\n    QQEhAgwECyAAQQF2IQIgAEEBakEBdiEEDAELQQAhBCAAIQILIAJBAWohAgJAA0AgAkF/aiICRQ0BIAEoAhggASgCBCABK\n    AIcKAIQEQMARQ0AC0EBIQIMAgsgASgCBCEHQQEhAiABKAIYIAUgAyABKAIcKAIMEQUADQEgBEEBaiEAIAEoAhwhAyABKA\n    IYIQQDQCAAQX9qIgAEQCAEIAcgAygCEBEDAEUNAQwDCwsgASALOgAgIAEgCjYCBEEAIQIMAQsgASgCBCEGQQEhAiABIAQ\n    gBxBTDQAgASgCGCAFIAMgASgCHCgCDBEFAA0AIAlBAWohACABKAIcIQMgASgCGCEBA0AgAEF/aiIARQRAQQAhAgwCCyAB\n    IAYgAygCEBEDAEUNAAsLIAhBMGokACACC7gGAQV/IwBBgAhrIgIkACACIAAQXiACIAEQDyACQYABaiAAQYABaiIDEF4gA\n    kGAAWogAUGAAWoiBRAPIAJBgAJqIABBgAJqIgQQXiACQYACaiABQYACaiIGEA8gAkGAA2ogABBeIAJBgANqIAMQlQEgAk\n    GAA2oQqAEgAkGABGogARBeIAJBgARqIAUQlQEgAkGABGoQqAEgAkGAA2ogAkGABGoQDyACQYAEaiACEJABIAJBgARqIAJ\n    BgAFqEJUBIAJBgANqIAJBgARqEH0gAkGAA2oQqAEgAkGABGogAxCQASACQYAEaiAEEJUBIAJBgARqEKgBIAJBgAVqIAUQ\n    XiACQYAFaiAGEJUBIAJBgAVqEKgBIAJBgARqIAJBgAVqEA8gAkGABWogAkGAAWoQkAEgAkGABWogAkGAAmoQlQEgAkGAB\n    GogAkGABWoQfSACQYAEahCoASACQYAFaiAAEJABIAJBgAVqIAQQlQEgAkGABWoQqAEgAkGABmogARBeIAJBgAZqIAYQlQ\n    EgAkGABmoQqAEgAkGABWogAkGABmoQDyACQYAGaiACEJABIAJBgAZqIAJBgAJqEJUBIAJBgAZqIAJBgAVqELUBIAJBgAZ\n    qEKgBIAJBgAVqIAIQkAEgAkGABWogAhCVASACIAJBgAVqEJUBIAIQqAEgAkGAAmpBDBCfASACQYACahBVIAJBgAJqEKgB\n    IAJBgAdqIAJBgAFqEF4gAkGAB2ogAkGAAmoQlQEgAkGAB2oQqAEgAkGAAWogAkGAAmoQfSACQYABahCoASACQYAGakEME\n    J8BIAJBgAZqEFUgAkGABmoQqAEgAkGABWogAkGABmoQkAEgAkGABWogAkGABGoQDyACQYACaiACQYADahCQASACQYACai\n    ACQYABahAPIAJBgAVqIAJBgAJqELUBIAJBgAZqIAIQDyACQYABaiACQYAHahAPIAJBgAZqIAJBgAFqEJUBIAIgAkGAA2o\n    QDyACQYAHaiACQYAEahAPIAJBgAdqIAIQlQEgACACQYAFahCQASAAEKgBIAMgAkGABmoQkAEgAxCoASAEIAJBgAdqEJAB\n    IAQQqAEgAkGACGokAAv2BQEFfyMAQYAEayICJAAgAiAAEIUBIAIgARBIIAJBQGsgAEFAayIDEIUBIAJBQGsgAUFAayIFE\n    EggAkGAAWogAEGAAWoiBBCFASACQYABaiABQYABaiIGEEggAkHAAWogABCFASACQcABaiADEHggAkHAAWoQRCACQYACai\n    ABEIUBIAJBgAJqIAUQeCACQYACahBEIAJBwAFqIAJBgAJqEEggAkGAAmogAhClASACQYACaiACQUBrEHggAkHAAWogAkG\n    AAmoQgAEgAkHAAWoQRCACQYACaiADEKUBIAJBgAJqIAQQeCACQYACahBEIAJBwAJqIAUQhQEgAkHAAmogBhB4IAJBwAJq\n    EEQgAkGAAmogAkHAAmoQSCACQcACaiACQUBrEKUBIAJBwAJqIAJBgAFqEHggAkGAAmogAkHAAmoQgAEgAkGAAmoQRCACQ\n    cACaiAAEKUBIAJBwAJqIAQQeCACQcACahBEIAJBgANqIAEQhQEgAkGAA2ogBhB4IAJBgANqEEQgAkHAAmogAkGAA2oQSC\n    ACQYADaiACEKUBIAJBgANqIAJBgAFqEHggAkGAA2ogAkHAAmoQswEgAkGAA2oQRCACQcACaiACEKUBIAJBwAJqIAIQeCA\n    CIAJBwAJqEHggAhBEIAJBgAFqQQwQUiACQcADaiACQUBrEIUBIAJBwANqIAJBgAFqEHggAkHAA2oQRCACQUBrIAJBgAFq\n    EIABIAJBQGsQRCACQYADakEMEFIgAkHAAmogAkGAA2oQpQEgAkHAAmogAkGAAmoQSCACQYABaiACQcABahClASACQYABa\n    iACQUBrEEggAkHAAmogAkGAAWoQswEgAkGAA2ogAhBIIAJBQGsgAkHAA2oQSCACQYADaiACQUBrEHggAiACQcABahBIIA\n    JBwANqIAJBgAJqEEggAkHAA2ogAhB4IAAgAkHAAmoQpQEgABBEIAMgAkGAA2oQpQEgAxBEIAQgAkHAA2oQpQEgBBBEIAJ\n    BgARqJAALxQUBBH8jAEHwEmsiACQAIAAQOEF/IQEgABCIAUUEQCAAQYADakE4EHIaIABBuANqQTgQchogAEG4A2ogAEGA\n    A2oQVCAAQfAKakG4gMAAEF8gAEHwDWpB8IDAABBfIABB8ANqIABB8ApqIABB8A1qEEkgAEHwBGpBOBByGiAAQQE2AqgFI\n    ABBsAVqQTgQchogAEHoBWpBATYCACAAQfAFakE4EHIaIABBATYCqAYgAEGwBmpBOBByGiAAQegGakEBNgIAIABB8AZqQT\n    gQchogAEEBNgKoByAAQbAHakE4EHIaIABB6AdqQQE2AgBBf2ohAyAAQfAHahAqIABB8AdqIAAQfiAAQfAKahAqIABB8Ap\n    qIABB8AdqEH4gAEHwDWoQKiAAQfANaiAAQfAHahB+IABB8A1qEJwBAkACQAJAA0AgAiEBIANBAkkNAyAAQfAKaiAAQfAE\n    aiAAQfAFaiAAQfAGahAlIAFBxABNBEAgAEHwEGogAEHwBGogAEHwBWogAEHwBmoQRiABQQh0QdCrwABqIABB8BBqEJIBI\n    AFBAWohAgJAAkAgAEG4A2ogA0F/aiIDEFcgAEGAA2ogAxBXa0EBag4DAQMAAwsgAEHwCmogAEHwB2ogAEHwBGogAEHwBW\n    ogAEHwBmoQHiABQcMASw0DIABB8BBqIABB8ARqIABB8AVqIABB8AZqEEYgAkEIdEHQq8AAaiAAQfAQahCSASABQQJqIQI\n    MAgsgAEHwCmogAEHwDWogAEHwBGogAEHwBWogAEHwBmoQHiABQcMASw0DIABB8BBqIABB8ARqIABB8AVqIABB8AZqEEYg\n    AkEIdEHQq8AAaiAAQfAQahCSASABQQJqIQIMAQsLIAFBxQBBvIHAABA8AAtBxQBBxQBBzIHAABA8AAtBxQBBxQBB3IHAA\n    BA8AAtBACEBCyAAQfASaiQAIAEL8gQBBH8jAEGADGsiAiQAIAIgABCOASACQYACahAvIAJBgARqIABBgAJqIgMQjgEgAk\n    GABmoQLyACQYAIaiAAEI4BIAJBgApqIAEQjgEgAiABEBkgAkGABGogAUGAAmoiBBAZIAJBgAhqIAMQlgEgAkGACmogBBC\n    WASACQYAIahCsASACQYAKahCsASACQYACaiACQYAIahCSASACQYACaiACQYAKahAZIAJBgAhqIAMQkgEgAkGACGogAEGA\n    BGoiBRCWASACQYAKaiAEEJIBIAJBgApqIAFBgARqIgQQlgEgAkGACGoQrAEgAkGACmoQrAEgAkGABmogAkGACGoQkgEgA\n    kGABmogAkGACmoQGSACQYAIaiACEJIBIAJBgAhqECsgAkGACmogAkGABGoQkgEgAkGACmoQKyACQYACaiACQYAIahCWAS\n    ADIAJBgAJqEJIBIAMgAkGACmoQlgEgAkGABmogAkGACmoQlgEgAkGABGogAkGACGoQlgEgAkGACGogABCSASACQYAIaiA\n    FEJYBIAJBgAhqEKwBIAJBgApqIAEQkgEgAkGACmogBBCWASACQYAKahCsASACQYAIaiACQYAKahAZIAJBgARqIAJBgAhq\n    EJYBIAJBgAhqIAUQkgEgAkGACGogBBAZIAJBgApqIAJBgAhqEJIBIAJBgApqECsgBSACQYAEahCSASAFIAJBgApqEJYBI\n    AJBgAZqIAJBgApqEJYBIAJBgAhqEGYgAyACQYAIahCWASACQYAGahCsASACQYAGahBmIAAgAhCSASAAIAJBgAZqEJYBIA\n    BBBTYCgAYgABCZASACQYAMaiQAC68EAQV/IwBBkAZrIgIkACAAQUBrIQQCQCABQfgAaigCACABKAI4aqwgAEH4AGooAgA\n    iAyAAKAI4IgVqrH5CgICAEFMNACAFQQJOBH8gABASIAAoAngFIAMLQQJIDQAgBBASCyACQaCnwAAQX0EAIQMgAkE4akHw\n    ABByGiABQUBrIQUDQCADQThGBEAgAkHwAGohBkEAIQMDQCADQThGRQRAIAMgBmogAiADaikDADcDACADQQhqIQMMAQsLI\n    AJBqAFqIAAQXyACQeABaiABEF8gAkGYAmogACABEAggAkGIA2ogBCAFEAggAkGoAWogBBBhIAJBqAFqEEQgAkHgAWogBR\n    BhIAJB4AFqEEQgAkH4A2ogAkGoAWogAkHgAWoQCEEAIQMgAkHoBGpB8AAQchoDQCADQfAARkUEQCACQegEaiADaiACQZg\n    CaiADaikDADcDACADQQhqIQMMAQsLIAJB6ARqIAJBiANqEGVBACEDA0AgA0HwAEZFBEAgAkGIA2ogA2oiASACQThqIANq\n    KQMAIAEpAwB9NwMAIANBCGohAwwBCwsgAkGYAmogAkGIA2oQZSACQZgCahBFIAJB+ANqIAJB6ARqEGQgAkH4A2oQRSACQ\n    dgFaiACQZgCahAFIAAgAkHYBWoQayAAQQM2AjggAkHYBWogAkH4A2oQBSAEIAJB2AVqEGsgAEECNgJ4IAJBkAZqJAAFIA\n    JBOGogA2pCADcDACADQQhqIQMMAQsLC5QEAQF/IwBB0CJrIgMkACADQcAWakG4gMAAEF8gA0HIHGpB8IDAABBfIANBCGo\n    gA0HAFmogA0HIHGoQSSADQYgBakE4EHIaIANBwAFqQTgQchogA0H4AWoQKgJAIAIQhAFFBEAgA0H4BGoQKiADQfgEaiAB\n    EH4gA0H4BGoQSiADQfgHahBLIANB+AdqIAIQfyADQfgHahBHIANByBxqIANB+AdqEIUBIANBuAlqIANByBxqEIUBIANBy\n    BxqIANBuAhqEIUBIANB+AlqIANByBxqEIUBIANBuApqECogA0G4DWoQYCADQbgKaiADQfgEahB+IANBwBNqECogA0HAE2\n    ogA0H4BGoQfiADQcATahCcASADQcABaiADQYgBahBUQX9qIQIDQCACQQFNBEAgA0G4DWoQkwEgACADQbgNakGIBhBnGgw\n    DBSADQbgNahAbIANBwBZqIANBuApqIANBuAlqIANB+AlqEBcCQAJAAkAgA0HAAWogAkF/aiICEFcgA0GIAWogAhBXa0EB\n    ag4DAQIAAgsgA0HIHGogA0G4CmogA0H4BGogA0G4CWogA0H4CWoQFiADQcAWaiADQcgcahAGDAELIANByBxqIANBuApqI\n    ANBwBNqIANBuAlqIANB+AlqEBYgA0HAFmogA0HIHGoQBgsgA0G4DWogA0HAFmoQBAwBCwALAAsgABBgCyADQdAiaiQAC8\n    MDARV/A0AgAUHAAUYEQAJAIABBKGohCyAAQRRqKAIAIgwhCCAAQRBqKAIAIg0hAyAAQQxqKAIAIg4hAiAAKAIIIg8hASA\n    AQRhqKAIAIhAhCiAAQRxqKAIAIhEhBCAAQSBqKAIAIhIhByAAQSRqKAIAIhMhBgNAIAchCSAEIQcgCiEEIAVBgAJGDQEg\n    AiADcSEUIAIgA3MhFSAFIAtqKAIAIAVB9J7AAGooAgAgBEEadyAEQRV3cyAEQQd3cyAGaiAJIARBf3NxIAQgB3FyampqI\n    gYgCGohCiAFQQRqIQUgAyEIIAIhAyABIQIgAUEedyABQRN3cyABQQp3cyAUIAEgFXFzaiAGaiEBIAkhBgwACwALBSAAIA\n    FqIgNB6ABqIANBzABqKAIAIANBKGooAgAgA0EsaigCACICQRl3IAJBDndzIAJBA3ZzIANB4ABqKAIAIgJBD3cgAkENd3M\n    gAkEKdnNqamo2AgAgAUEEaiEBDAELCyAAIAYgE2o2AiQgACAJIBJqNgIgIAAgByARajYCHCAAIAQgEGo2AhggACAIIAxq\n    NgIUIAAgAyANajYCECAAIAIgDmo2AgwgACABIA9qNgIIC9YDAgZ/An4jAEHwAGsiASQAIAFBoKfAABBfIAFBOGogARBfI\n    AAQRAJAAkACQCABAn8gACgCOCICQRBMBEAgAkF/ahA5DAELIAEpAzAiCEIBfCIHIAhUDQEgACkDMCIIQoCAgICAgICAgH\n    9RQQAgB0J/URsNAiABQThqIAggB3+nECghByABIAEpA2ggB0I6hnw3A2ggACABQThqEGIgABBEQQILIgMQLSAAQQhqIQQ\n    DQCADRQ0DIAEgASkDCEI5hkKAgICAgICAgAKDIAEpAwBCAYeEIgc3AwAgASAAKQMAIAd9IgdC//////////8DgzcDOEEA\n    IQIDQCAHQjqHIQcgAkEoRkUEQCABIAJqIgVBCGoiBiAFQRBqKQMAQjmGQoCAgICAgICAAoMgBikDAEIBh4QiCDcDACABI\n    AJqQUBrIAIgBGopAwAgCH0gB3wiB0L//////////wODNwMAIAJBCGohAgwBCwsgASABKQMwQgGHIgg3AzAgASAAKQMwIA\n    h9IAd8Igc3A2ggACABQThqIAdCP4enQQFqEE8gA0F/aiEDDAALAAtBoKLAAEEZQbyiwAAQWwALQdCiwABBH0G8osAAEFs\n    ACyAAQQE2AjggAUHwAGokAAuhAwEBfyMAQZADayIGJAAgBkEIakHAABByGiAGQcgAakGoAhByGiAGQcgAahBDA0AgAQRA\n    IAZByABqQQAQPiABQX9qIQEMAQUCQCACBEAgBkHIAGogAiADEHoLIAQEQCAGQcgAaiAEIAUQegsgBkGIA2pCADcDACAGQ\n    YADakIANwMAIAZB+AJqQgA3AwAgBkIANwPwAiAGKAJIIQEgBigCTCECIAZByABqQYABED4DQCAGKAJIQf8DcUHAA0ZFBE\n    AgBkHIAGpBABA+DAELCyAGQawBaiABNgIAIAZBqAFqIAI2AgAgBkHIAGoQEUEAIQJBACEBA0AgAUEgRkUEQCAGQfACaiA\n    BaiABQXxxIAZqQdAAaigCACACQX9zQRhxdjoAACACQQhqIQIgAUEBaiEBDAELCyAGQcgAahBDQQAhAQNAIAFBIEZFBEAg\n    BkEIaiABaiAGQfACaiABai0AADoAACABQQFqIQEMAQsLQQAhAQNAIAFBIEYNASAAIAFqIAZBCGogAWotAAA6AAAgAUEBa\n    iEBDAALAAsLCyAGQZADaiQAC6EDAQN/IwBBgAZrIgEkACABIABBgAFqIgMQXiABQYABaiADEF4gAUGAAWoQMiABQYACai\n    ABEF4gAUGAAmogAEGAAmoiAhAPIAFBgANqIAIQXiABQYADahAyIAIgAUGAAWoQkAEgAiABQYABahCVASACEKgBIAIQpwE\n    gAhCnASACEKgBIAFBgANqQQwQnwEgAUGAA2oQVSABQYADahCoASABQYAEaiABQYADahBeIAFBgARqIAIQDyABQYAFaiAB\n    QYABahBeIAFBgAVqIAFBgANqEJUBIAFBgAVqEKgBIAIgAUGAAmoQDyABQYACaiABQYADahCQASABQYACaiABQYADahCVA\n    SABQYADaiABQYACahCVASABQYADahCoASABQYABaiABQYADahB9IAFBgAFqEKgBIAFBgAVqIAFBgAFqEA8gAUGABWogAU\n    GABGoQlQEgAUGAAmogABCQASABQYACaiABEA8gACABQYABahCQASAAEKgBIAAgAUGAAmoQDyAAEKcBIAAQqAEgAyABQYA\n    FahCQASADEKgBIAFBgAZqJAALhQMBBH8CQAJAIAFBgAJPBEAgAEEYaigCACEEAkACQCAAIAAoAgwiAkYEQCAAQRRBECAA\n    QRRqIgIoAgAiAxtqKAIAIgENAUEAIQIMAgsgACgCCCIBIAI2AgwgAiABNgIIDAELIAIgAEEQaiADGyEDA0AgAyEFIAEiA\n    kEUaiIDKAIAIgFFBEAgAkEQaiEDIAIoAhAhAQsgAQ0ACyAFQQA2AgALIARFDQIgACAAQRxqKAIAQQJ0QeS3wQBqIgEoAg\n    BHBEAgBEEQQRQgBCgCECAARhtqIAI2AgAgAkUNAwwCCyABIAI2AgAgAg0BQdi1wQBB2LXBACgCAEF+IAAoAhx3cTYCAA8\n    LIABBDGooAgAiAiAAQQhqKAIAIgBHBEAgACACNgIMIAIgADYCCA8LQdS1wQBB1LXBACgCAEF+IAFBA3Z3cTYCAAwBCyAC\n    IAQ2AhggACgCECIBBEAgAiABNgIQIAEgAjYCGAsgAEEUaigCACIARQ0AIAJBFGogADYCACAAIAI2AhgLC7MCAQF/IwBBg\n    AtrIgUkACAFEC8gBUGAAmoQLyAFQYAEahAvIAVBgAZqQTgQchogBUEBNgK4BiAFQcAGakE4EHIaIAVB+AZqQQE2AgAgBU\n    GAB2pBOBByGiAFQQE2ArgHIAVBwAdqQTgQchogBUH4B2pBATYCACAFQYAIakE4EHIaIAVBATYCuAggBUHACGpBOBByGiA\n    FQfgIakEBNgIAIAEgAiAFQYAGaiAFQYAHaiAFQYAIahAeIAVBgAhqIAMQoAEgBUGABmogBBCgASAFQYAJaiAFQYAGaiAF\n    QYAHahCRASAFIAVBgAlqEJIBIAVBgAlqIAVBgAhqEJsBIAVBgARqIAVBgAlqEJIBIAVBgARqEGYgACAFIAVBgAJqIAVBg\n    ARqEHYgAEEDNgKABiAFQYALaiQAC7ECAQF/IwBBgAtrIgQkACAEEC8gBEGAAmoQLyAEQYAEahAvIARBgAZqQTgQchogBE\n    EBNgK4BiAEQcAGakE4EHIaIARB+AZqQQE2AgAgBEGAB2pBOBByGiAEQQE2ArgHIARBwAdqQTgQchogBEH4B2pBATYCACA\n    EQYAIakE4EHIaIARBATYCuAggBEHACGpBOBByGiAEQfgIakEBNgIAIAEgBEGABmogBEGAB2ogBEGACGoQJSAEQYAIaiAC\n    EKABIARBgAZqIAMQoAEgBEGACWogBEGABmogBEGAB2oQkQEgBCAEQYAJahCSASAEQYAJaiAEQYAIahCbASAEQYAEaiAEQ\n    YAJahCSASAEQYAEahBmIAAgBCAEQYACaiAEQYAEahB2IABBAzYCgAYgBEGAC2okAAvJAgEDfyMAQcACayIBJAAgASAAQU\n    BrIgMQhQEgARADIAFBQGsgAxCFASABQUBrIABBgAFqIgIQSCABQYABaiACEIUBIAFBgAFqEAMgAiABEKUBIAIgARB4IAI\n    QRCACEE4gAhBOIAIQRCABQYABakEMEFIgAUHAAWogAUGAAWoQhQEgAUHAAWogAhBIIAFBgAJqIAEQhQEgAUGAAmogAUGA\n    AWoQeCABQYACahBEIAIgAUFAaxBIIAFBQGsgAUGAAWoQpQEgAUFAayABQYABahB4IAFBgAFqIAFBQGsQeCABIAFBgAFqE\n    IABIAEQRCABQYACaiABEEggAUGAAmogAUHAAWoQeCABQUBrIAAQpQEgAUFAayADEEggACABEKUBIAAQRCAAIAFBQGsQSC\n    AAEE4gABBEIAMgAUGAAmoQpQEgAxBEIAFBwAJqJAALrQIBA38jAEGABGsiAiQAIAIgABBeIAJBgAFqIABBgAFqIgMQXiA\n    CQYACakE4EHIaIAJBATYCuAIgAkHAAmpBOBByGiACQfgCakEBNgIAIAJBgANqIAMQXiACIAEQDyACQYABaiABQYABaiIE\n    EA8gAkGAAmogBBCQASACQYACaiABEJUBIAJBgANqIAAQlQEgAkGAAmoQqAEgAkGAA2oQqAEgAkGAA2ogAkGAAmoQDyACQ\n    YACaiACEJABIAJBgAJqEDogAkGAA2ogAkGAAmoQlQEgAkGAA2oQqAEgAkGAAmogAkGAAWoQkAEgAkGAAmoQOiADIAJBgA\n    NqEJABIAMgAkGAAmoQlQEgAkGAAWoQVSAAIAJBgAFqEJABIAAgAhCVASAAEKwBIAJBgARqJAALvQIBA38jAEGACGsiASQ\n    AIAEgABCOASABQYACaiAAQYAEaiICEI4BIAFBgARqIABBgAJqIgMQjgEgAUGABmoQLyAAECIgAUGABmogABCSASABQYAG\n    aiAAEJYBIAAgAUGABmoQlgEgABCsASABELYBIAEQrwEgACABEJYBIAFBgAJqECIgAUGAAmoQZiABQYAGaiABQYACahCSA\n    SABQYAGaiABQYACahCWASABQYACaiABQYAGahCWASABQYACahCsASABQYAEahAiIAFBgAZqIAFBgARqEJIBIAFBgAZqIA\n    FBgARqEJYBIAFBgARqIAFBgAZqEJYBIAFBgARqEKwBIAMQrgEgAxCvASACELYBIAIQrwEgAyABQYACahCWASACIAFBgAR\n    qEJYBIABBBTYCgAYgABCaASABQYAIaiQAC7ICAQN/IwBBgAhrIgEkACAAKAKABkEBRwRAIAEgABCOASABQYACaiAAQYAC\n    aiIDEI4BIAFBgARqIABBgARqIgIQjgEgAUGABmogABCOASABECIgAUGAAmogAhAZIAFBgAJqEK8BIAFBgAJqEKwBIAFBg\n    ARqECIgAUGABmogAxAZIAFBgAZqEK8BIAIgABCWASACIAMQlgEgAhCsASACECIgACABEJIBIAEgAUGAAmoQlgEgARCsAS\n    ABIAFBgARqEJYBIAEgAUGABmoQlgEgARCsASABECsgAUGAAmoQZiABQYAEahBmIAAgAUGAAmoQlgEgAyABQYAEahCSASA\n    DIAFBgAZqEJYBIAIgARCWASAAQQRBBSAAKAKABkF+cUECRhs2AoAGIAAQmQELIAFBgAhqJAALigIBAn8jAEHgAWsiAiQA\n    IAAQRCACQQhqQTAQchogAkIBNwMAIAJBOGogABBfIAJB8ABqIAEQXyACQagBakE4EHIaIAAQdANAIAJBOGogAkHwAGoQN\n    UF/TARAA0ACQCADQQBMDQAgAkHwAGpBARA7IAJBARA7IAJBqAFqIAJBOGoQayACQagBaiACQfAAahBiIAJBqAFqEEQgAk\n    E4aiACQagBaiACKQPYAUI/h6dBAWoiARBPIAJBqAFqIAAQayACQagBaiACEGEgAkGoAWoQRCAAIAJBqAFqIAEQTyADQX9\n    qIQMMAQsLBSACQQEQLSACQfAAakEBEC0gA0EBaiEDDAELCyACQeABaiQAC54CAQF/IwBBgA1rIgMkACADIAEQaiADEJkB\n    IANBiAZqIAIQXyADQYgGahBEIANBwAZqIANBiAZqEF8gA0HABmpBAxAoGiADQcAGahBEIANB+AZqIAMQagJAIANBwAZqE\n    FpFBEAgA0HABmoQKUF/aiECA0AgAkEBTQRAIANB+AZqEJoBDAMLIANB+AZqEBoCQAJAIANBwAZqIAJBf2oiAhBXIANBiA\n    ZqIAIQV2tBAWoOAwECAAILIANB+AZqIAMQDgwBCyADEJMBIANB+AZqIAMQDiADEJMBDAALAAsgA0H4BmoQsAEgA0H4B2o\n    QqQEgA0H4CGoQrQEgA0H4CmoQrQEgA0EBNgL4DAsgACADQfgGakGIBhBnGiADQYANaiQAC5ACAQJ/IwBBgAJrIgUkACAF\n    QYABaiAAEF4gAiAFQYABahCQASAFQYABaiAAQYABahBeIAQgBUGAAWoQkAEgBUGAAWogAEGAAmoiBhBeIAUgBUGAAWoQX\n    iAFQYABaiAGEF4gAyAFQYABahCQASAFQYABaiABQYABaiIGEF4gBSAFQYABahAPIAVBgAFqIAEQXiADIAVBgAFqEA8gAi\n    ADEH0gAhCoASAEIAUQfSAEEKgBIAUgAhCQASACEFUgAhCoASAFQYABaiAGEF4gBSAFQYABahAPIAMgBBCQASAFQYABaiA\n    BEF4gAyAFQYABahAPIAMgBRB9IAMQqAEgBBA6IAQQqAEgACABEAsgBUGAAmokAAvkAQECfyMAQcABayIDJAAgAxBLIAAg\n    ASACQR91IgQgAnMgBEF/c2pBAm0iAkF/akEfdhBtIAAgAUHAAWogAkEBc0F/akEfdhBtIAAgAUGAA2ogAkECc0F/akEfd\n    hBtIAAgAUHABGogAkEDc0F/akEfdhBtIAAgAUGABmogAkEEc0F/akEfdhBtIAAgAUHAB2ogAkEFc0F/akEfdhBtIAAgAU\n    GACWogAkEGc0F/akEfdhBtIAAgAUHACmogAkEHc0F/akEfdhBtIAMgABB/IAMQpgEgACADIARBAXEQbSADQcABaiQAC+Q\n    BAQJ/IwBBgANrIgMkACADECogACABIAJBH3UiBCACcyAEQX9zakECbSICQX9qQR92EG8gACABQYADaiACQQFzQX9qQR92\n    EG8gACABQYAGaiACQQJzQX9qQR92EG8gACABQYAJaiACQQNzQX9qQR92EG8gACABQYAMaiACQQRzQX9qQR92EG8gACABQ\n    YAPaiACQQVzQX9qQR92EG8gACABQYASaiACQQZzQX9qQR92EG8gACABQYAVaiACQQdzQX9qQR92EG8gAyAAEH4gAxCcAS\n    AAIAMgBEEBcRBvIANBgANqJAALvAEBAn8jAEGwAWsiAiQAIAJBMBByIQIDQCADQTBGBEACQCABQTBqIQEgAkEwaiACEHV\n    BACEDA0AgA0EwRg0BIAIgA2ogASADai0AADoAACADQQFqIQMMAAsACwUgAiADaiABIANqLQAAOgAAIANBAWohAwwBCwsg\n    AkHwAGogAhB1IABBOBByIgBBATYCOCAAQUBrQTgQciAAQfgAakEBNgIAIAAgAkHwAGoQpQEgAkEwahClASACQbABaiQAC\n    9QBAQJ/IwBBgANrIgEkACABIAAQXiABQYABaiAAQYABaiICEF4gAUGAAmogABBeIAFBgAJqIAIQDyABIAIQlQEgAUGAAW\n    oQVSABQYABaiAAEJUBIAEQqAEgAUGAAWoQqAEgACABEJABIAAgAUGAAWoQDyABQYABaiABQYACahCQASABQYABahBVIAF\n    BgAFqIAFBgAJqEJUBIAFBgAFqEKgBIAFBgAFqEDogACABQYABahCVASABQYACahCnASACIAFBgAJqEJABIAAQrAEgAUGA\n    A2okAAvEAQEBfyMAQYADayIDJAAgA0EIaiABEIUBAkAgAkUEQCADQQhqEAcMAQsgA0EIaiACEKUBCyADQcgAakHYo8AAE\n    F8gA0GAAWogA0HIAGoQiwEgA0HAAWogA0EIahCFASADQcABahADIANBwAFqIAEQSCAAIAEQhQEgACADQQhqEEggA0GAAm\n    ogA0HAAWoQhQEgABBYIQEgA0HAAmogABCFASADQcACahBBIANBwAJqEEQgACADQcACaiABEHkgA0GAA2okAAufAQEBfyM\n    AQfAAayICJAAgAiABEF9BACEBIAJBOGpBOBByGiAAEEQCQCAAIAIQNUEASA0AA0AgAkEBEC0gAUEBaiEBIAAgAhA1QX9K\n    DQALA0AgAUEATA0BIAJBARA7IAJBOGogABBrIAJBOGogAhBiIAJBOGoQRCAAIAJBOGogAikDaEI/h6dBAWoQTyABQX9qI\n    QEMAAsACyACQfAAaiQAC7IBAQF/IwBBgAJrIgQkACAEQYABaiAAEF4gAyAEQYABahCQASAEQYABaiAAQYABahBeIAQgBE\n    GAAWoQXiAEQYABaiAAQYACahBeIAIgBEGAAWoQkAEgASAEEJABIAEgAhAPIAMQMiAEEDIgAhAyIAEQpwEgARA6IAEQqAE\n    gARBVIAEQqAEgAkEMEJ8BIANBAxCfASACEFUgAhCoASACIAQQfSACEKgBIAAQFCAEQYACaiQAC58BAQJ/IwBBgAJrIgIk\n    ACAAIAEQXiAAEDIgAkGIAWpB2KTAABBfIAJBCGpBOBByGiACQQE2AkAgAkHIAGpBOBByIAJBgAFqQQE2AgAgAkHAAWogA\n    kGIAWoQiwEgAkEIaiACQcABahClARCyASACQQhqEKgBIAJBCGoQVSACQQhqEKgBIAAgARAPIAAgAkEIahCVASAAEKsBIA\n    JBgAJqJAALowEBAX8jAEEwayIGJAAgBkEQaiAAIAEQsQEgBiAGKAIUIgA2AhwgBiAGKAIQIgE2AhggBkEIaiACIAMQsQE\n    gBiAGKAIMIgI2AiQgBiAGKAIIIgM2AiAgBiAEIAUQsQEgBiAGKAIEIgQ2AiwgBiAGKAIAIgU2AiggASAAIAMgAiAFIAQQ\n    ACAGQShqEKQBIAZBIGoQpAEgBkEYahCkASAGQTBqJAALiAECA38DfiMAQRBrIgIkAAN+IANBOEYEfiACQRBqJAAgBgUgA\n    iAAIANqIgQpAwAiBSAFQj+HIAGsIgUgBUI/hxAxIAQgAikDACIHIAZ8IgVC//////////8DgzcDACAFIAdUrSACQQhqKQ\n    MAIAZCP4d8fEIGhiAFQjqIhCEGIANBCGohAwwBCwsLhAECA38BfiMAQUBqIgEkACABQQhqIAAQXyABQQhqEEQgAUE4aiE\n    CQQYhA0HcAiEAAn8DQEEAIANBAEgNARogAikDACIEUARAIAJBeGohAiAAQUZqIQAgA0F/aiEDDAELCwN/IARQBH8gAAUg\n    AEEBaiEAIARCAn8hBAwBCwsLIAFBQGskAAuHAQEBfyMAQcABayIBJAAgAEE4EHIiAEEBNgI4IABBQGtBOBByGiAAQfgAa\n    kEBNgIAIAEQUCABQYgBakE4EHIaIABBgAFqIAFBgAEQZxogAEGAAmpBOBByGiAAQbgCakEBNgIAIABBvAJqIAFBhAFqQT\n    wQZxogAEH4AmpBATYCACABQcABaiQAC48BAQJ/IwBBgAJrIgEkACAAEKwBIAEgABBeIAFBgAFqQTgQchogAUEBNgK4ASA\n    BQcABakE4EHIaIAFB+AFqQQE2AgAgASAAQYABaiICEJUBIAEQOiABQYABaiABEJABIAFBgAFqIAIQlQEgAiABEJABIAIg\n    ABCVASAAIAFBgAFqEJABIAAQrAEgAUGAAmokAAt9AgF/An4jAEGAAWsiASQAIAFBCGogABCFASABQQhqEBIgAUHIAGogA\n    UEIahCDAUEIIQADQCAAQThGRQRAIAFByABqIABqKQMAIAKEIQIgAEEIaiEADAELCyABKQNIIQMgAUGAAWokACACQn98IA\n    NCAYVCf3yDQjqIp0EBcQuJAQIBfwJ+IAAgACkDMCABQT9xrSIDhiAAKQMoQTogAWtBP3GtIgSHhDcDMCAAQShqIQFBBiE\n    CA0AgAkEBTQRAIAAgACkDACADhkL//////////wODNwMABSABIAEpAwAgA4ZC//////////8DgyABQXhqIgEpAwAgBIeE\n    NwMAIAJBf2ohAgwBCwsLiQECAX8CfiAAIAApA2BBOiABQTpwIgFrrSIEhyAAKQNoIAGtIgOGhDcDaCAAQeAAaiEBQQ0hA\n    gNAIAJBAU0EQCAAIAApAwAgA4ZC//////////8DgzcDAAUgASABKQMAIAOGQv//////////A4MgAUF4aiIBKQMAIASHhD\n    cDACACQX9qIQIMAQsLC3EBAX8jAEFAaiIBJAAgAEE4EHIiAEEBNgI4IABBQGtBOBByGiAAQfgAakEBNgIAIAFBCGpBOBB\n    yGiAAQYABakE4EHIaIABBuAFqQQE2AgAgAEG8AWogAUEEakE8EGcaIABB+AFqQQE2AgAgAUFAayQAC4EBAgF/AX4gAEHw\n    ABByIQADQCACQThGBEACQCAAIAEpAzAiA0I6hzcDOCAAIANC//////////8DgzcDMCAAQUBrIQBBACECA0AgAkEwRg0BI\n    AAgAmpCADcDACACQQhqIQIMAAsACwUgACACaiABIAJqKQMANwMAIAJBCGohAgwBCwsLdQECfiAAIANCIIgiBSABQiCIIg\n    Z+IAIgA358IAEgBH58IANC/////w+DIgIgAUL/////D4MiAX4iA0IgiCACIAZ+fCICQiCIfCABIAV+IAJC/////w+DfCI\n    BQiCIfDcDCCAAIANC/////w+DIAFCIIaENwMAC3YBAn8jAEHAAWsiASQAIAEgABCFASABQUBrIAAQhQEgAUGAAWogAEFA\n    ayICEIUBIAEgAhB4IAFBQGsgABB4IAFBQGsQRCACIAFBQGsQSCABQYABahBBIAAgAUGAAWoQeCABEEQgABBEIAAgARBII\n    AFBwAFqJAALkwEBAn9B0LXBAEHQtcEAKAIAQQFqNgIAAkACQEGYucEAKAIAQQFGBEBBnLnBAEGcucEAKAIAQQFqIgA2Ag\n    AgAEECSw0CQaC5wQAoAgAiAUF/Sg0BDAILQZi5wQBCgYCAgBA3AwBBoLnBACgCACIAQQBIDQFBoLnBACAANgIAAAtBoLn\n    BACABNgIAIABBAUsNAAALAAtnAQJ/IwBBQGoiAiQAIAAQRCACIAAQhQECQCABRQRAIAAQBwwBCyAAIAEQpQELQQAhAQNA\n    IAFBAUsgA3JFBEAgABADIAFBAEchAyABIAFFaiEBDAELCyAAIAIQSCAAEBIgAkFAayQAC18CAX8EfkIBIQNBMCECA38gA\n    kF4RgR/IARCAYYgA3ynQX9qBSABIAJqKQMAIgUgACACaikDACIGfUI6hyADgyAEhCEEIAJBeGohAiAFIAaFQn98QjqHIA\n    ODIQMMAQsLC2ACAX8EfkIBIQNB6AAhAgN/IAJBeEYEfyAEQgGGIAN8p0F/agUgASACaikDACIFIAAgAmopAwAiBn1COoc\n    gA4MgBIQhBCACQXhqIQIgBSAGhUJ/fEI6hyADgyEDDAELCwt3AQN/IwBBgAJrIgIkACACIAEQXiACQYABaiABEF4gAhAy\n    IAJBgAFqIAIQDyAAIAJBgAFqEJcBIABBgAJqIgMgAkGAAWoQlwEgAEGABGoiBCACQYABahCXASADIAEQogEgBCACEKIBI\n    ABBBTYCgAYgAkGAAmokAAt6AQF/IwBB4ANrIgEkACABQYABakHApcAAEF8gAUG4AWpB+KXAABBfIAEgAUGAAWogAUG4AW\n    oQSSABQfACakGwpsAAEF8gAUGoA2pB6KbAABBfIAFB8AFqIAFB8AJqIAFBqANqEEkgACABIAFB8AFqED8gAUHgA2okAAt\n    nACAAQQF2IAByIgBBAnYgAHIiAEEEdiAAciIAQQh2IAByIgBBEHYgAHIiACAAQQF2QdWq1aoFcWsiAEECdkGz5syZA3Eg\n    AEGz5syZA3FqIgBBBHYgAGpBj568+ABxQYGChAhsQRh2C2cBAn8jAEGAAWsiASQAIAEgABCFASABQUBrQTgQchogAUEBN\n    gJ4IAEgAEFAayICEHggARBBIAFBQGsgARClASABQUBrIAIQeCACIAEQpQEgAiAAEHggACABQUBrEKUBIAFBgAFqJAALaA\n    IBfwJ+IAFBP3GtIQNBOiABa0E/ca0hBEEAIQEDQCABQTBGBEAgACAAKQMwIAOHNwMwBSAAIAFqIgIgAkEIaikDACAEhkL\n    //////////wODIAIpAwAgA4eENwMAIAFBCGohAQwBCwsLbAEBfyMAQTBrIgMkACADIAE2AgQgAyAANgIAIANBHGpBAjYC\n    ACADQSxqQQI2AgAgA0ICNwIMIANBlKjAADYCCCADQQI2AiQgAyADQSBqNgIYIAMgAzYCKCADIANBBGo2AiAgA0EIaiACE\n    HAAC2wBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQRxqQQI2AgAgA0EsakECNgIAIANCAjcCDCADQbCqwAA2AgggA0\n    ECNgIkIAMgA0EgajYCGCADIANBBGo2AiggAyADNgIgIANBCGogAhBwAAtlAQJ/IAAgACgCACICQQhqIgM2AgAgACACQQN\n    2QTxxakEoaiICIAFB/wFxIAIoAgBBCHRyNgIAAkACQCADRQRAIABBADYCACAAIAAoAgRBAWo2AgQMAQsgA0H/A3ENAQsg\n    ABARCwtnAQF/IwBBgAJrIgMkACAAECogACABEJABIABBgAFqIgEgAhCQASAAQYACahCwASAAEKgBIAMgABAmIANBgAFqI\n    AEQXiADQYABahAyIANBgAFqIAMQe0UEQCAAEJgBCyADQYACaiQAC18BAn8jAEGAAWsiASQAIAAQqAEgASAAEIUBIAFBQG\n    sgAEFAayICEIUBIAEQAyABQUBrEAMgASABQUBrEHggAUEAEDQgACABEEggARBBIAEQRCACIAEQSCABQYABaiQAC10BAn8\n    jAEFAaiIBJAAgAUEIakGgp8AAEF8gAUEIaiAAKAI4QX9qEDkiAhAtIAAgAUEIahBjIABBASACQQFqQR9xdCICNgI4IAJB\n    gICAEE4EQCAAEBILIAFBQGskAAtfAgF/AX4jAEHwAGsiASQAIAFBoKfAABBfIAApAwAhAiABQThqIAAQXyAAQQEQOyABQ\n    ThqIAEQYSABQThqEEQgAUE4akEBEDsgACABQThqIAJCAoGnEE8gAUHwAGokAAt7AQJ/IABBKGohAgNAIAFBgAJGBEAgAE\n    LnzKfQ1tDrs7t/NwIIIABCADcCACAAQSBqQquzj/yRo7Pw2wA3AgAgAEEYakL/pLmIxZHagpt/NwIAIABBEGpC8ua746O\n    n/aelfzcCAAUgASACakEANgIAIAFBBGohAQwBCwsLaQICfwF+IAAgACkDACIDQv//////////A4M3AwBBCCEBA0AgA0I6\n    hyEDIAFBMEYEQCAAIAApAzAgA3w3AzAFIAAgAWoiAiACKQMAIAN8IgNC//////////8DgzcDACABQQhqIQEMAQsLC2oCA\n    n8BfiAAIAApAwAiA0L//////////wODNwMAQQghAQNAIANCOochAyABQegARgRAIAAgACkDaCADfDcDaAUgACABaiICIA\n    IpAwAgA3wiA0L//////////wODNwMAIAFBCGohAQwBCwsLWQEBfyMAQYADayIEJAAgBCADEF4gBBBAIARBgAFqIAEQXiA\n    EQYACaiACEF4gBEGAAWogBBAPIARBgAJqIAQQDyAAIARBgAFqIARBgAJqEJEBIARBgANqJAALWQECfyMAQUBqIgEkAAJA\n    IAAQhAENACABQQEQigEgAEGAAWoiAiABEFkNACACQQAQNCAAIAIQSCAAEBIgAEFAayIAIAIQSCAAEBIgAiABEKUBCyABQ\n    UBrJAALVwEBfyMAQbABayICJAAgATQCOCAANAI4fkKAgIAQWQRAIAAQEgsgAkEIaiAAIAEQCCACQfgAaiACQQhqEAUgAC\n    ACQfgAahBrIABBAjYCOCACQbABaiQAC08BAn8jAEFAaiIDJAAgAEE4EHIiAEEBNgI4IABBQGtBOBByIABB+ABqQQE2AgA\n    gAyABEIsBIAAgAxClASADIAIQiwEgAxClASADQUBrJAALWQECfyMAQYABayIBJAACQCAAEIgBDQAgARBQIABBgAJqIgIg\n    ARB7DQAgAhBAIAAgAhAPIAAQqwEgAEGAAWoiACACEA8gABCrASACIAEQkAELIAFBgAFqJAALSwEBfyMAQUBqIgEkACAAQ\n    TgQciIAQQE2AjggAUEBEIoBIABBQGsgAUHAABBnGiAAQYABakE4EHIaIABBuAFqQQE2AgAgAUFAayQAC0sBAn8jAEHwAG\n    siASQAIAAQd0UEQCABQaCnwAAQXyABQThqIAAQgwEgASABQThqEGIgARBEIAFBOGogARA1IQILIAFB8ABqJAAgAgtPAQF\n    /IwBBgAFrIgIkACAAIAEQhQEgABADIAJByABqQdikwAAQXyACQQhqIAJByABqEIsBIAAgARBIIAAgAkEIahB4IAAQEiAC\n    QYABaiQAC0kBAn8DQCABQThGRQRAIAAgAWoiAiACKQMAQgGGNwMAIAFBCGohAQwBCwsgACAAKAI4QQF0IgE2AjggAUGAg\n    IAQTgRAIAAQEgsLQgIBfwJ+QQAgAmusIQQDQCADQThHBEAgACADaiICIAIpAwAiBSABIANqKQMAhSAEgyAFhTcDACADQQ\n    hqIQMMAQsLC0YBAn8jAEFAaiIBJAAgAEE4EHIiAEEBNgI4IABBQGtBOBByIABB+ABqQQE2AgAgAUEBEIoBIAAgARClARC\n    yASABQUBrJAALTgEBfyMAQYAEayIBJAAgABAvIAEQLyABQYACahAvIABBgAJqIAFBgAIQZxogAEGABGogAUGAAmpBgAIQ\n    ZxogAEEANgKABiABQYAEaiQAC0sBAX8jAEFAaiICJAACQCAAKAI4IAFsQYCAgBBOBEAgAiABEIoBIAAgAhBIDAELIAAgA\n    RAoGiAAIAAoAjggAWw2AjgLIAJBQGskAAtKAAJ/IAFBgIDEAEcEQEEBIAAoAhggASAAQRxqKAIAKAIQEQMADQEaCyACRQ\n    RAQQAPCyAAKAIYIAJBACAAQRxqKAIAKAIMEQUACwtCAQF/IwBBQGoiAiQAIAJBCGpBgIDAABBfIAEgAkEIahBrIAEQRCA\n    AIAEQayAAQQMQKBogABBEIAAQKSACQUBrJAALSQECfyMAQcABayIBJAAgASAAEF4gAUGAAWogABCFASAAIABBQGsiAhCl\n    ASAAEEEgAiABQYABahClASAAIAEQlQEgAUHAAWokAAtIAQF/IwBB4AFrIgEkACABQeihwAAQXyABQThqIAAgARAIIAFBq\n    AFqIAFBOGoQBSAAIAFBqAFqEGsgAEECNgI4IAFB4AFqJAALPgEBfyABQTpuIQIgAUGVA00EQCAAIAJBA3RqKQMAQgEgAU\n    H//wNxQTpwrYaDQgBVDwsgAkEHQdSdwAAQPAALQAIBfwF+IwBBgAFrIgEkACABQQhqIAAQhQEgAUEIahASIAFByABqIAF\n    BCGoQgwEgASkDSCABQYABaiQAQgKBpws8AQF/IwBBgAFrIgIkACACIAAQhQEgAkFAayABEIUBIAIQEiACQUBrEBIgAiAC\n    QUBrEDUgAkGAAWokAEULPAIBfwF+A38gAUE4RgR/IAJCf3xCgICAgICAgIAEg0I6iKcFIAAgAWopAwAgAoQhAiABQQhqI\n    QEMAQsLC0cBAX8jAEEgayIDJAAgA0EUakEANgIAIANB9KrAADYCECADQgE3AgQgAyABNgIcIAMgADYCGCADIANBGGo2Ag\n    AgAyACEHAACzkBAX8jAEFAaiICJAAgAiAAEIUBIAIQByABBEAgASACEKUBCyACEAMgAiAAEEggAhAsIAJBQGskAAs6AQF\n    /IABBOBByIQADQCACQTBGRQRAIABBCBAtIAAgACkDACABIAJqMQAAfDcDACACQQFqIQIMAQsLCzQBAX8gAEE4EHIiAEEB\n    NgI4IABBQGtBOBByIABB+ABqQQE2AgAgACABEKUBIAFBQGsQpQELMAEBfyAAQTgQciEAA0AgAkE4RwRAIAAgAmogASACa\n    ikDADcDACACQQhqIQIMAQsLCz8BAX8jAEGAAmsiASQAIAAQUSABEG4gACABEJIBIABBgAJqEK0BIABBgARqEK0BIABBAT\n    YCgAYgAUGAAmokAAswAQJ/A0AgAkE4RwRAIAAgAmoiAyADKQMAIAEgAmopAwB8NwMAIAJBCGohAgwBCwsLMAECfwNAIAJ\n    BOEcEQCAAIAJqIgMgAykDACABIAJqKQMAfTcDACACQQhqIQIMAQsLCzABAn8DQCACQThHBEAgACACaiIDIAEgAmopAwAg\n    AykDAH03AwAgAkEIaiECDAELCwsxAQJ/A0AgAkHwAEcEQCAAIAJqIgMgAykDACABIAJqKQMAfTcDACACQQhqIQIMAQsLC\n    zEBAn8DQCACQfAARwRAIAAgAmoiAyADKQMAIAEgAmopAwB8NwMAIAJBCGohAgwBCwsLOQECfyMAQYABayIBJAAgASAAQY\n    ABaiICEF4gAiAAEJABIAEQVSAAIAEQkAEgABCsASABQYABaiQACzMBAX8gAgRAIAAhAwNAIAMgAS0AADoAACABQQFqIQE\n    gA0EBaiEDIAJBf2oiAg0ACwsgAAtIAQN/IwBBEGsiASQAIAAoAgwhAyAAKAIIIgJFBEBB9KrAAEErQaCrwAAQWwALIAEg\n    AzYCCCABIAA2AgQgASACNgIAIAEQcQALMgEBfyAAQgE3AwBBCCEBA0AgAUE4RkUEQCAAIAFqQgA3AwAgAUEIaiEBDAELC\n    yAAEFYLNwAgABBRIAAgARCSASAAQYACaiABQYACahCSASAAQYAEaiABQYAEahCSASAAIAEoAoAGNgKABgsoAQF/A0AgAk\n    E4RwRAIAAgAmogASACaikDADcDACACQQhqIQIMAQsLCzMAIAAgARCSASAAQYACaiABQYACahCSASAAQYAEaiABQYAEahC\n    SASAAIAEoAoAGNgKABgsoACAAIAEgAhB5IABBQGsgAUFAayACEHkgAEGAAWogAUGAAWogAhB5Cy4BAX8jAEGAAWsiASQA\n    IAAQLyABEFAgACABEJABIABBgAFqEKkBIAFBgAFqJAALLQAgACABIAIQjwEgAEGAAWogAUGAAWogAhCPASAAQYACaiABQ\n    YACaiACEI8BCzQBAX8jAEEQayICJAAgAiABNgIMIAIgADYCCCACQaSowAA2AgQgAkH0qsAANgIAIAIQaAALPgEBfyMAQR\n    BrIgEkACABQQhqIABBCGooAgA2AgAgASAAKQIANwMAIAEoAgAiAEEUaigCABogACgCBBoQMwALKQEBfyABBEAgACECA0A\n    gAkEAOgAAIAJBAWohAiABQX9qIgENAAsLIAALKwEBfyMAQcABayICJAAgAhBLIAIgARB/IAIQpgEgACACEAwgAkHAAWok\n    AAsiAQF/A0AgAUE4RwRAIAAgAWpCADcDACABQQhqIQEMAQsLCycBAX8jAEFAaiICJAAgAkEIaiABEF0gACACQQhqEIsBI\n    AJBQGskAAsrACAAEFEgACABEJIBIABBgAJqIAIQkgEgAEGABGogAxCSASAAQQU2AoAGCyMBAX8jAEFAaiIBJAAgASAAEI\n    UBIAEQEiABEFogAUFAayQACykAIAAgARBhIAAgACgCOCABKAI4aiIBNgI4IAFBgICAEE4EQCAAEBILCyUAIAAgASACEE8\n    gAEEAIAJrIAAoAjgiACABKAI4c3EgAHM2AjgLIwADQCACBEAgACABLQAAED4gAkF/aiECIAFBAWohAQwBCwsLIgACQCAA\n    IAEQWUUNACAAQUBrIAFBQGsQWUUNAEEBDwtBAAskAAJAIABBfE0EQCAARQRAQQQhAAwCCyAAEAEiAA0BCwALIAALJwEBf\n    yMAQYABayICJAAgAiABEF4gAhA6IAAgAhCVASACQYABaiQACycAIAAgARCQASAAQYABaiABQYABahCQASAAQYACaiABQY\n    ACahCQAQslACAAIAEQpQEgAEFAayABQUBrEKUBIABBgAFqIAFBgAFqEKUBCyUBAX8jAEFAaiICJAAgAiABEIUBIAIQQSA\n    AIAIQeCACQUBrJAALKAEBfyMAQYACayICJAAgAiABEI4BIAIQKyAAIAIQlgEgAkGAAmokAAsjAEGEAiACSQRAIAJBhAIg\n    AxA9AAsgACACNgIEIAAgATYCAAsiAQF/IwBB8ABrIgIkACACIAEQMCAAIAIQBSACQfAAaiQACxwAAkAgABB3RQ0AIABBg\n    AFqEHdFDQBBAQ8LQQALHwAgAEE4EHIiAEEBNgI4IAAgARBrIAAgASgCODYCOAseAAJAIAAQhwFFDQAgAEGAAWoQhwFFDQ\n    BBAQ8LQQALGwACQCAAEHdFDQAgAEFAaxB3RQ0AQQEPC0EACx4AAkAgABCHAUUNACAAQYACahCHAUUNAEEBDwtBAAsaAQF\n    /IAAQWCIBIABBQGsQWCABcyAAEHdxcwsaACAAQTgQciIAQQE2AjggACABEJ0BIAAQVgsZACAAQTgQciIAQQE2AjggACAB\n    EGsgABBWCxcAIAAQRCAAKAIAQX8gAUEfcXRBf3NxCxoAIAAgARBfIAAgAhAkIAAgAhBjIAAgAhAkCxwAIAAQLyAAIAEQk\n    AEgAEGAAWogAUGAAWoQkAELGAAgACABIAIQeSAAQUBrIAFBQGsgAhB5CxYAIAAgARClASAAQUBrIAFBQGsQpQELGAAgAB\n    AvIAAgARCQASAAQYABaiACEJABCxgAIAAgARCQASAAQYABaiABQYABahCQAQsZACAAEK4BIABBgAJqELYBIABBgARqEK4\n    BCxcAIAAQsgEgAEFAaxBpIABBgAFqELIBCxQAIAAgARB4IABBQGsgAUFAaxB4CxgAIAAgARCVASAAQYABaiABQYABahCV\n    AQsYACAAEKYBIABBgAFqIgAQpgEgACABEA8LGQAgABCpASAAQYABahCwASAAQYACahCpAQsZACAAEKwBIABBgAJqEKwBI\n    ABBgARqEKwBCxkAIAAQqgEgAEGAAmoQqgEgAEGABGoQqgELFgAgABAvIAAgARCQASAAQYABahCpAQsWACAAQYABaiIAEK\n    gBIAAQOiAAEKgBCxQAIAAQRCAAIAApAwAgAax8NwMACxQAIAAQRCAAIAApAwAgAax9NwMACxEAIAAgARBSIABBQGsgARB\n    SCxEAIAAgARBIIABBQGsgARBICxQAIAAgARCQASAAQYABaiACEJABCxIAIAAgARAPIABBgAFqIAEQDwsUACAAIAEQoAEg\n    AEGAAWogARCgAQsRACAAKAIEBEAgACgCABAJCwsSACAAIAEQayAAIAEoAjg2AjgLDwAgAEFAayIAEEEgABBECw0AIAAQT\n    iAAQUBrEE4LDQAgABBEIABBQGsQRAsPACAAELIBIABBQGsQsgELEAAgABCrASAAQYABahCrAQsNACAAEBIgAEFAaxASCx\n    AAIAAQqAEgAEGAAWoQqAELEAAgABCpASAAQYABahCpAQsPACAAQYABahA6IAAQrAELEAAgABCnASAAQYABahCnAQsOACA\n    AEGkgAEFAaxCyAQsQACAAIAI2AgQgACABNgIACw0AIAAQdCAAQQE2AjgLDAAgABBBIAAgARB4CwwAIAAgARBrIAAQVgsN\n    ACAAEDogACABEJUBCwsAIAAQOiAAEKwBCwwAQunQotvMouq7RgsDAAELAwABCwv+PZoCAEGCgMAACwcBAAAAAQI0AEG4g\n    MAAC9sBuF8jku11BwFjT+D5WE+pA2dPnKtLeD0Akew9ffXy9AMD1g8fDSwgAK1vjPCZwa4A8DtNkAEAAADzStxtEor3AI\n    uwH1tTsFYDgvLFYx+X7AAysL/NHtseAkehVLifHyMCQHo6ogw4sQGz4sMPAAAAAHNyYy9ibHMxMjM4MS9wYWlyLnJzqAA\n    QABQAAAAHAQAACQAAAKgAEAAUAAAADAEAAA0AAACoABAAFAAAABEBAAANAAAAAAAAAAEAAAD///8Dv/+W/78AaQM7VYAd\n    moCAAefMIPV1pkwBp+1zAEGogsAACyz+//7///8BAosAgILYBPYB4Y1oiW++kwLOdqvfPagdAMZpulHOdt8Dy1nGFwBB4\n    ILAAAuRAZABEAATAAAA0AEAABgAAACQARAAEwAAANQBAAARAAAAkAEQABMAAADWAQAAHAAAAHNyYy9ibHMxMjM4MS9lY3\n    AucnMAkAEQABMAAAAZBQAADQAAAJABEAATAAAAGwUAAAkAAACQARAAEwAAABwFAAARAAAAkAEQABMAAAAfBQAAHAAAAAA\n    AAAABAAEAAAABAjQAQaCEwAALuSCQARAAEwAAAGcEAAARAAAAkAEQABMAAABsBAAADQAAAJABEAATAAAAbgQAABUAAACQ\n    ARAAEwAAAHAEAAAgAAAAHUxYLQgo9ADXXz44aOPbAInJGoj9roEBomOjmrkPTgGY6rCCSW3JAoBOWs9QOu4AimlEAQAAA\n    ADgKxeO6UjMAXSpOluMVsgAolXvNe/8FADngsIBPcnDA8EWIDvuPnUAusRiAAwgWgDRCCkuAQAAALgh6L1iEMUA3/4Vlz\n    tIpQGLCDH8A9S9AbsR/Cc0UtIDHfAS2hvXowEqPc423S/bAshidB8AAAAAKdKiiy66yAHqR06TLeDGAiSMtsYkvPEDAo/\n    w3iCL+AGd1zE97u2BA4ilRy+cg4kDSMIIbgAAAAB7+wUWP99nAjJ7Fwrjx90CaW+GFDsANgMrVFv+4Zl3A8x9+g1bVtIB\n    Aju2nPiBcwIH2iEDAQAAAJ4MOb5nECQDX97JALfLQgIx+rexS69LAYydZXIx6AACyy7dIo8TXQHUDYML8enzAuH4sWkBA\n    AAAF+OXhGqYcQFbpdOtpXylAPrkHV2MkmwBFovSVX2eswF1O8QNmb5jAc0s5B7x42kCH8/TgAAAAACOyPDjGFbLAOdrHT\n    0yPvIBmzNTJw/vYgALmsY2bZ2sAuVtNVN+EdEAIQ4duvj2agBw54F7AQAAAITtOaEl8tcBt7JLQTBKlADaqLKGnI8hAiN\n    AhjM+PJkAhhWxv1LmigOwyY1aShP5A1Nl7dYAAAAAgyllb8bBEwFzRs+5ckvDAQgK+Wh+CbkCTntu5kll9wGxPNu1Sqf3\n    AwZIdMD/xFwDUDIMYwEAAADZlYis6UwVARTxnQfMG4oChYnB+oJZtgK7IfzsX0loAZnbmVSOEeQDLK2Q2RB9ZgCjJpfpA\n    AAAAGFomx1kiLMB8WQcxDiXuAEzNQgzG58oA8zGl/w2qpUB5PXXElTlBwN0goHTbRvzA2ZxjncBAAAAsNyerJ2fFwD4p1\n    yCSo8PA1jJJY7GHlAC46GVD2alzAEkA84bmgrRATESRAc7nl0C2wVA1QAAAAC7g8uz8e40ALrVMMa8qTwCg7SGHg3HMwK\n    X1V8Qqr1sAecXfByoRyECrC5iwcvqUAI+7ZRyAQAAALdJRnNiFqwCq1uLuXy1MABhhSxO22y1A4nJfwFciyICPjBrhRWY\n    2QEHRAIu0MygA7HyBRoBAAAACt3saNGEYwELQBne0pLTATFZwTGPlzMBfdvdQN9bugO0gvaAZqWzAo9b2xG1SnoCqxP8l\n    QAAAABB1qF5Oux2AxHckO6qpJkAOFCDmPNn2gBA0K3ZhMV1AI1/4Myjx68Bz4Kkl+BTaQNqzw6hAAAAAF5azL2b2fcBxL\n    R4RCdSbgH6gMUimN8cAltmoKIpbwgDY39umQHPdABs/SyMLCpZA6nCekoBAAAAOkrobkl0JQA7G3jD49TsAKfO6e0qBnM\n    AuDglhk69ZgJXD1chZ1ngAxiDz0OGTVoAz6osdwAAAAClBGOfovktAHDEowjxkjQAQPeCiUvyzgMOKTS1cjqnAzVXOenG\n    BgUD30NOVe6ZOQGOXzXnAAAAAB6iMjVbOZ0DVAdezQfqpgC9qW0wO4NOAK017oqBhGYBx9//faDnQwNXx5sCKkWKACAWj\n    joBAAAA2CzGjZPoDQMEcT27D0m1AZcE/dYovIoCMlNFlcVa/AAkCFtU60B8A/urDrK/uGIBGlglNAAAAAAZPrhcujnCAD\n    +3PyWfJfQAas3qrBEL4ACZ8kczxmm9AUGJbx+Z8r8BivlNoJfI6AHlL5ayAAAAAP87K8huJ8gBeboJLBshqgI9cfWLxIg\n    lAJsEMADCMygD6EFwNjblmAJEHC3SEGfVAt6lYSUBAAAAHBvSQPr5PAEmfg+Nb6A1AlUrxor8F4YAVnLqIm2NLgHv1QFv\n    +tNLA4u5LIZrxj8DSNWojAAAAAAEtshpvla0AMEdB7C/n0ABZisb8FqpTwG3XuVoWRI+Ah0Yy7Uu30IDzkKpk/PAQwLp5\n    GteAQAAAEsidVRxHmsC4e1rXtkmQQC6Rs6nltP1AKxmo5WhXwcCPWde/KPESAN9VqhAxDORA0WWElwAAAAAMwGY2/XT2Q\n    IQmcoIRyvkA2zMWQbE0zICmU8AVjA1IAA7e3XcFeN7AisAv9ymskcDSjlaJAAAAAD4HpcL8ARMAYN8hGRkcBQCbPAzRnu\n    ADgGcADvCmtCoALGnekQ/9QQAWEJVdObkBgDByoKxAAAAAI5NB9CkyAcCs4E10QZ9cwKdJEP2EfnnA6+5GAnDq+ICWTVS\n    zO3S/gNQMEaut73NAwipRosBAAAAMsER0BpxEwA6v+6PM5fOAxsDYZ44FuQDYET/JL2yLQPLL82T+0MdA+NCf4NvNN8Ae\n    eQTlwEAAAAwHHPK66qvA8qbrlN3FdwDs7lDTR7t5wFhGvjba0WeAgwqxCNKoa0Dea+OSG2vYQChp7vhAAAAAIel23tXDj\n    cA2OiB4XGAlAGd5qsM8qHmAi16sAl3nlkAvTqPu6FNHgKIJyP6EpplA4sBxJ8AAAAAKftwGKNMXgFoTfq3P1SRAS9kQsg\n    mbNoADvR/YPeO/wIFChd0xqYsAa9Jpvcbrs4AU418mAAAAADy1ulfhfhhAbJX0IORsB4CenTzNNbEEwDFSC0Thq8oA7hb\n    5zxreScA9F2yLO8G6wO8ubBKAAAAAPClMzaxOrIBphygVrLJ2AMD4kRVrdPDAUHZ9d62vlID0Kd0oKbwuAFHeISI2tIYA\n    KT8A2YBAAAA2/7o8uzatgEQKhBkAjf+Ae7CrVETIv0DDObhQjmP7wM2VRnEKRWiAvjTK9fEP/gD3j/AjAAAAADL9OWwd1\n    w1Ail7h7GnrhYA5J3PUTLAPgKSJ3DkrTvkAqcq1FdndNgCRh0mXggHJgJuN4YfAAAAAPbhLcdA4t8A7kgBLIqFVAMmfdo\n    AFLnkAxINi3OMYlkD4lIllEk7agAy4Si9mZulArqGxwwAAAAAlsZBLlrnlwD4L+qLZcRZAWxN03q2PjQCQT704DyVsAHp\n    IxKDRvt2A7UNRHUEljsBEGqZNAEAAAAzuweXcUWYAq/w6M6mux4D0Dw9VFbJ9gJKrUiloSI5AhOtEfrcgEkBwkdnCbiT6\n    AKBfNmQAAAAAI9LYx06RxUAEeAlTTxcvQDKBaLKVmPNAzvJTOHOiZcBD8RxwRl4DQJXCcmaD3C3AYEd+uAAAAAA9wbtJh\n    Pc+gE0IDPFYe9FASDkgCSUJ98A0i0Hn6ScUwJbVr/yds1TAUP3otjOk8sCDkBgJgAAAADMRTNXOLGZAkewQu742AEAMGm\n    42QCa7wJz9ZkIfCtmA0YzVJYUX7QAUUzY8PifHQMUlWutAAAAAJIQVuIptYQCpfqu3xsmWgJvURN56oyoAT4wSgs5vysC\n    /5R/RwzFSAIHS2H9z0AHAnS2y6wAAAAAqGqPupy0+AAAgcHg06dwARqHXGpjbrMBZDmkmIbt5gDQbZwdkdIaACgEPFJvA\n    akDniUvTQAAAABVP5G4i/RuAI3XbEr1qBcCc7xPfernkgEhTO0e9oSPAfcWMpCEStkDZYGgOoebwgHaXKVnAQAAAEpdU1\n    WdPSMD2iCS5O69+AMshbQ5v8RQAxWvgmS9GpMDDPv5xEzX0QNT+YbGSBjbANOObIYBAAAA2S6BFVpB7gAYuXcAAmw9AJI\n    rE1djIP0AzfpfP33oewE3pOVu/6a7An4374D6qY8Di/A+agEAAABcd2oSmRMaAU/ux2JpAKcCXx0FoADEWwJNd73jMzTq\n    A/3sXkuC6awAzaHu8Mt2pgIIfABmAQAAAKy3+ap/R8YCgDhz6ndu4wCfRKb18LaHAbMXB2JDVRkDUgG3gjF4rAK6mexny\n    7ZhAJdSno0AAAAAHQClESMUOQJ2e7v0A3fFAiBqkeyd/KABu1DB7qY9fAKc0cbcjSL4AkQyAyz50BcBlQcOvgAAAAAWVF\n    9EmG3SAGrrpaCwPNkAJxf0anKeSAL2SDhM83ZvA8UV0dG07YkD70iDfOWUYwKHKH1rAQAAAPJnvz21OCUCR+Jbvo01XwF\n    nyi7NedJdAtYwxPy5RlUBhcR4V7GObgGfq+rbiTaQAQYz31gAAAAAPaBJLiwQ9gJMjafU2IEJAYr3AT5FbzUAhJJyVhPH\n    3ANPyIW4SMNDAFsvg4YHSOAAwnUtlgEAAADBYzawU5JHAUAbCIO9I9oAf6Dncr61MgIMu5svYOKVA20aYOnq0PoAUASGl\n    CwmpwLDxBJhAQAAAHNyYy9ibHMxMjM4MS9iaWcucnMAoA4QABMAAADMAQAALQAAAKAOEAATAAAAzAEAADUAAACgDhAAEw\n    AAABkCAAANAAAAoA4QABMAAAA4AwAAGAAAAKAOEAATAAAAOAMAACEAAACgDhAAEwAAAEIDAAAhAAAAoA4QABMAAABbAwA\n    AFwAAAKAOEAATAAAAZAMAABcAAACgDhAAEwAAAHIDAAAwAAAAoA4QABMAAAB7AwAAMAAAAKAOEAATAAAApwMAABgAAACg\n    DhAAEwAAALUDAAAYAAAAmC+KQpFEN3HP+8C1pdu16VvCVjnxEfFZpII/ktVeHKuYqgfYAVuDEr6FMSTDfQxVdF2+cv6x3\n    oCnBtybdPGbwcFpm+SGR77vxp3BD8yhDCRvLOktqoR0StypsFzaiPl2UlE+mG3GMajIJwOwx39Zv/ML4MZHkafVUWPKBm\n    cpKRSFCrcnOCEbLvxtLE0TDThTVHMKZbsKanYuycKBhSxykqHov6JLZhqocItLwqNRbMcZ6JLRJAaZ1oU1DvRwoGoQFsG\n    kGQhsNx5Md0gntbywNLMMHDlKqthOT8qcW/NvLmjugo90b2OleBR4yIQIAseM+v++kOtsUKT3o/m+8nhxxkJMU19TSUdf\n    QkxTMTIzODFHMV9YTUQ6U0hBLTI1Nl9TU1dVX1JPX05VTF8A0BAQABMAAAA/AAAALgAAANAQEAATAAAAPQAAABUAAADQE\n    BAAEwAAAD0AAAANAAAAc3JjL2JsczEyMzgxL2Jscy5ycwAAAAAArve+1aE5BgLok91iZEwkAdIsbk61CS0C2+VwMbbEEQ\n    GZYzb76G2KA7ycH+3PFk8AK2qmngEAAABhdHRlbXB0IHRvIGRpdmlkZSBieSB6ZXJvAAAAbxEQABIAAAB8AQAAFAAAAAA\n    AAABhdHRlbXB0IHRvIGRpdmlkZSB3aXRoIG92ZXJmbG93c3JjL2JsczEyMzgxL2ZwLnJzAAAAbxEQABIAAAASAgAADQAA\n    AG8REAASAAAAHgIAACYAAABvERAAEgAAAB4CAAAjAAAAbxEQABIAAAAkAgAAFwAAAG8REAASAAAAJAIAABQAAAAAAAAAq\n    qr//////gHu//9UrP//AupBYg9rDyoBw5z9ShTOEwJLd2TXrEtDAu3pxpKm+V8Cox4RoAEAAABAEhAAFAAAABUBAAATAA\n    AAQBIQABQAAAAeAQAAGAAAAEASEAAUAAAAJAEAABwAAABzcmMvYmxzMTIzODEvZWNwMi5ycwAAAAAEAEGQpcAAC7wGQBI\n    QABQAAADmAgAACQAAAEASEAAUAAAA7gIAAA0AAABAEhAAFAAAAP4CAAAhAAAAuL0hwchWgAD1+24BqskAA7pwFz2uR7YA\n    RNEK7ADpUwN65MZREMUtA0kBgkmkwiMALyuqJAAAAAB+KwRdBX2sAflVF+WERDwDNJME9ce9GwJp12rYgmRCA9BrWWVPJ\n    4gA6DRrH9hnnAAFtgI+AQAAAAEouAiGVJMBeKIo6w5zsgIjyRINFpWmAQq1nU73MqoCm/2tGjUu2gJxczJjhFufAHdSXc\n    4AAAAAvnlf8F8HqQJqaAc710nDAfOzmulytSoB0pm8jp0W+gEoPsuZi8IrAKw0qwwzzakDAkpsYAAAAACrqv/////+Ae7\n    //1Ss//8C6kFiD2sPKgHDnP1KFM4TAkt3ZNesS0MC7enGkqb5XwKjHhGgAQAAAAgUEAALAAAAjwEAAA8AAAAIFBAACwAA\n    AKcBAAATAAAACBQQAAsAAACqAQAADQAAAHNyYy9obWFjLnJzADQUEAAgAAAAVBQQABIAAAADAAAAAAAAAAEAAAAEAAAAa\n    W5kZXggb3V0IG9mIGJvdW5kczogdGhlIGxlbiBpcyAgYnV0IHRoZSBpbmRleCBpcyAwMDAxMDIwMzA0MDUwNjA3MDgwOT\n    EwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIyMjMyNDI1MjYyNzI4MjkzMDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ\n    0NTQ2NDc0ODQ5NTA1MTUyNTM1NDU1NTY1NzU4NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5\n    ODA4MTgyODM4NDg1ODY4Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OQAAQBUQABAAAABQFRAAIgAAAHJhbmdlIGVuZCBpb\n    mRleCAgb3V0IG9mIHJhbmdlIGZvciBzbGljZSBvZiBsZW5ndGggAABjYWxsZWQgYE9wdGlvbjo6dW53cmFwKClgIG9uIG\n    EgYE5vbmVgIHZhbHVlALAVEAAcAAAA7gEAAB4AAABsaWJyYXJ5L3N0ZC9zcmMvcGFuaWNraW5nLnJzAEGIrMAACwEBAEH\n    IrMAACwEBAEGIrcAACwEBAEHIrcAACwEBAEGIrsAACwEBAEHIrsAACwEBAEGIr8AACwEBAEHIr8AACwEBAEGIsMAACwEB\n    AEHIsMAACwEBAEGIscAACwEBAEHIscAACwEBAEGIssAACwEBAEHIssAACwEBAEGIs8AACwEBAEHIs8AACwEBAEGItMAAC\n    wEBAEHItMAACwEBAEGItcAACwEBAEHItcAACwEBAEGItsAACwEBAEHItsAACwEBAEGIt8AACwEBAEHIt8AACwEBAEGIuM\n    AACwEBAEHIuMAACwEBAEGIucAACwEBAEHIucAACwEBAEGIusAACwEBAEHIusAACwEBAEGIu8AACwEBAEHIu8AACwEBAEG\n    IvMAACwEBAEHIvMAACwEBAEGIvcAACwEBAEHIvcAACwEBAEGIvsAACwEBAEHIvsAACwEBAEGIv8AACwEBAEHIv8AACwEB\n    AEGIwMAACwEBAEHIwMAACwEBAEGIwcAACwEBAEHIwcAACwEBAEGIwsAACwEBAEHIwsAACwEBAEGIw8AACwEBAEHIw8AAC\n    wEBAEGIxMAACwEBAEHIxMAACwEBAEGIxcAACwEBAEHIxcAACwEBAEGIxsAACwEBAEHIxsAACwEBAEGIx8AACwEBAEHIx8\n    AACwEBAEGIyMAACwEBAEHIyMAACwEBAEGIycAACwEBAEHIycAACwEBAEGIysAACwEBAEHIysAACwEBAEGIy8AACwEBAEH\n    Iy8AACwEBAEGIzMAACwEBAEHIzMAACwEBAEGIzcAACwEBAEHIzcAACwEBAEGIzsAACwEBAEHIzsAACwEBAEGIz8AACwEB\n    AEHIz8AACwEBAEGI0MAACwEBAEHI0MAACwEBAEGI0cAACwEBAEHI0cAACwEBAEGI0sAACwEBAEHI0sAACwEBAEGI08AAC\n    wEBAEHI08AACwEBAEGI1MAACwEBAEHI1MAACwEBAEGI1cAACwEBAEHI1cAACwEBAEGI1sAACwEBAEHI1sAACwEBAEGI18\n    AACwEBAEHI18AACwEBAEGI2MAACwEBAEHI2MAACwEBAEGI2cAACwEBAEHI2cAACwEBAEGI2sAACwEBAEHI2sAACwEBAEG\n    I28AACwEBAEHI28AACwEBAEGI3MAACwEBAEHI3MAACwEBAEGI3cAACwEBAEHI3cAACwEBAEGI3sAACwEBAEHI3sAACwEB\n    AEGI38AACwEBAEHI38AACwEBAEGI4MAACwEBAEHI4MAACwEBAEGI4cAACwEBAEHI4cAACwEBAEGI4sAACwEBAEHI4sAAC\n    wEBAEGI48AACwEBAEHI48AACwEBAEGI5MAACwEBAEHI5MAACwEBAEGI5cAACwEBAEHI5cAACwEBAEGI5sAACwEBAEHI5s\n    AACwEBAEGI58AACwEBAEHI58AACwEBAEGI6MAACwEBAEHI6MAACwEBAEGI6cAACwEBAEHI6cAACwEBAEGI6sAACwEBAEH\n    I6sAACwEBAEGI68AACwEBAEHI68AACwEBAEGI7MAACwEBAEHI7MAACwEBAEGI7cAACwEBAEHI7cAACwEBAEGI7sAACwEB\n    AEHI7sAACwEBAEGI78AACwEBAEHI78AACwEBAEGI8MAACwEBAEHI8MAACwEBAEGI8cAACwEBAEHI8cAACwEBAEGI8sAAC\n    wEBAEHI8sAACwEBAEGI88AACwEBAEHI88AACwEBAEGI9MAACwEBAEHI9MAACwEBAEGI9cAACwEBAEHI9cAACwEBAEGI9s\n    AACwEBAEHI9sAACwEBAEGI98AACwEBAEHI98AACwEBAEGI+MAACwEBAEHI+MAACwEBAEGI+cAACwEBAEHI+cAACwEBAEG\n    I+sAACwEBAEHI+sAACwEBAEGI+8AACwEBAEHI+8AACwEBAEGI/MAACwEBAEHI/MAACwEBAEGI/cAACwEBAEHI/cAACwEB\n    AEGI/sAACwEBAEHI/sAACwEBAEGI/8AACwEBAEHI/8AACwEBAEGIgMEACwEBAEHIgMEACwEBAEGIgcEACwEBAEHIgcEAC\n    wEBAEGIgsEACwEBAEHIgsEACwEBAEGIg8EACwEBAEHIg8EACwEBAEGIhMEACwEBAEHIhMEACwEBAEGIhcEACwEBAEHIhc\n    EACwEBAEGIhsEACwEBAEHIhsEACwEBAEGIh8EACwEBAEHIh8EACwEBAEGIiMEACwEBAEHIiMEACwEBAEGIicEACwEBAEH\n    IicEACwEBAEGIisEACwEBAEHIisEACwEBAEGIi8EACwEBAEHIi8EACwEBAEGIjMEACwEBAEHIjMEACwEBAEGIjcEACwEB\n    AEHIjcEACwEBAEGIjsEACwEBAEHIjsEACwEBAEGIj8EACwEBAEHIj8EACwEBAEGIkMEACwEBAEHIkMEACwEBAEGIkcEAC\n    wEBAEHIkcEACwEBAEGIksEACwEBAEHIksEACwEBAEGIk8EACwEBAEHIk8EACwEBAEGIlMEACwEBAEHIlMEACwEBAEGIlc\n    EACwEBAEHIlcEACwEBAEGIlsEACwEBAEHIlsEACwEBAEGIl8EACwEBAEHIl8EACwEBAEGImMEACwEBAEHImMEACwEBAEG\n    ImcEACwEBAEHImcEACwEBAEGImsEACwEBAEHImsEACwEBAEGIm8EACwEBAEHIm8EACwEBAEGInMEACwEBAEHInMEACwEB\n    AEGIncEACwEBAEHIncEACwEBAEGInsEACwEBAEHInsEACwEBAEGIn8EACwEBAEHIn8EACwEBAEGIoMEACwEBAEHIoMEAC\n    wEBAEGIocEACwEBAEHIocEACwEBAEGIosEACwEBAEHIosEACwEBAEGIo8EACwEBAEHIo8EACwEBAEGIpMEACwEBAEHIpM\n    EACwEBAEGIpcEACwEBAEHIpcEACwEBAEGIpsEACwEBAEHIpsEACwEBAEGIp8EACwEBAEHIp8EACwEBAEGIqMEACwEBAEH\n    IqMEACwEBAEGIqcEACwEBAEHIqcEACwEBAEGIqsEACwEBAEHIqsEACwEBAEGIq8EACwEBAEHIq8EACwEBAEGIrMEACwEB\n    AEHIrMEACwEBAEGIrcEACwEBAEHIrcEACwEBAEGIrsEACwEBAEHIrsEACwEBAEGIr8EACwEBAEHIr8EACwEBAEGIsMEAC\n    wEBAEHIsMEACwEBAEGIscEACwEBAEHIscEACwEBAEGIssEACwEBAEHIssEACwEBAEGIs8EACwEBAEHIs8EACwEBAEGItM\n    EACwEBAEHItMEACwEBAEGItcEACwEBAEHItcEACwEBAHsJcHJvZHVjZXJzAghsYW5ndWFnZQEEUnVzdAAMcHJvY2Vzc2V\n    kLWJ5AwVydXN0Yx0xLjQ5LjAgKGUxODg0YThlMyAyMDIwLTEyLTI5KQZ3YWxydXMGMC4xOC4wDHdhc20tYmluZGdlbhIw\n    LjIuNzAgKGI2MzU1YzI3MCk=\n`.replace(/[^0-9a-zA-Z/+]/g, '');\nconst wasmBytes = base64Arraybuffer.decode(wasmBytesBase64);\n/**\n * @returns {number}\n */\nexport function bls_init() {\n    let ret = wasm.bls_init();\n    return ret;\n}\nlet cachegetUint8Memory0 = null;\nfunction getUint8Memory0() {\n    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {\n        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);\n    }\n    return cachegetUint8Memory0;\n}\nfunction passArray8ToWasm0(arg, malloc) {\n    const ptr = malloc(arg.length * 1);\n    getUint8Memory0().set(arg, ptr / 1);\n    return [ptr, arg.length];\n}\n/**\n * @param {Uint8Array} sig\n * @param {Uint8Array} m\n * @param {Uint8Array} w\n * @returns {number}\n */\nexport function bls_verify(sig, m, w) {\n    const [ptr0, len0] = passArray8ToWasm0(sig, wasm.__wbindgen_malloc);\n    const [ptr1, len1] = passArray8ToWasm0(m, wasm.__wbindgen_malloc);\n    const [ptr2, len2] = passArray8ToWasm0(w, wasm.__wbindgen_malloc);\n    const ret = wasm.bls_verify(ptr0, len0, ptr1, len1, ptr2, len2);\n    return ret;\n}\nasync function load(module, imports) {\n    if (typeof Response === 'function' && module instanceof Response) {\n        const bytes = await module.arrayBuffer();\n        return await WebAssembly.instantiate(bytes, imports);\n    }\n    else {\n        const instance = await WebAssembly.instantiate(module, imports);\n        if (instance instanceof WebAssembly.Instance) {\n            return { instance, module };\n        }\n        else {\n            return instance;\n        }\n    }\n}\nasync function init() {\n    const imports = {};\n    const { instance, module } = await load(wasmBytes, imports);\n    wasm = instance.exports;\n    init.__wbindgen_wasm_module = module;\n    return wasm;\n}\n/**\n * If `module_or_path` is {RequestInfo} or {URL}, makes a request and\n * for everything else, calls `WebAssembly.instantiate` directly.\n *\n * @param {InitInput | Promise<InitInput>} module_or_path\n *\n * @returns {Promise<InitOutput>}\n */\nexport default init;\n//# sourceMappingURL=bls.js.map","import init, { bls_init, bls_verify } from '../vendor/bls/bls';\nexport let verify;\n/**\n *\n * @param pk primary key: Uint8Array\n * @param sig signature: Uint8Array\n * @param msg message: Uint8Array\n * @returns Promise resolving a boolean\n */\nexport async function blsVerify(pk, sig, msg) {\n    if (!verify) {\n        await init();\n        if (bls_init() !== 0) {\n            throw new Error('Cannot initialize BLS');\n        }\n        verify = (pk1, sig1, msg1) => {\n            // Reorder things from what the WASM expects (sig, m, w).\n            return bls_verify(sig1, msg1, pk1) === 0;\n        };\n    }\n    return verify(pk, sig, msg);\n}\n//# sourceMappingURL=bls.js.map","import { Buffer } from 'buffer/';\nimport { getDefaultAgent } from './agent';\nimport * as cbor from './cbor';\nimport { AgentError } from './errors';\nimport { hash } from './request_id';\nimport { blobFromBuffer, blobFromText, blobFromUint8Array, blobToHex, blobToUint8Array, } from '@dfinity/candid';\nimport { blsVerify } from './utils/bls';\n/**\n * A certificate needs to be verified (using {@link Certificate.prototype.verify})\n * before it can be used.\n */\nexport class UnverifiedCertificateError extends AgentError {\n    constructor() {\n        super(`Cannot lookup unverified certificate. Call 'verify()' first.`);\n    }\n}\n/**\n * Make a human readable string out of a hash tree.\n * @param tree\n */\nexport function hashTreeToString(tree) {\n    const indent = (s) => s\n        .split('\\n')\n        .map(x => '  ' + x)\n        .join('\\n');\n    function labelToString(label) {\n        const decoder = new TextDecoder(undefined, { fatal: true });\n        try {\n            return JSON.stringify(decoder.decode(label));\n        }\n        catch (e) {\n            return `data(...${label.byteLength} bytes)`;\n        }\n    }\n    switch (tree[0]) {\n        case 0:\n            return '()';\n        case 1: {\n            const left = hashTreeToString(tree[1]);\n            const right = hashTreeToString(tree[2]);\n            return `sub(\\n left:\\n${indent(left)}\\n---\\n right:\\n${indent(right)}\\n)`;\n        }\n        case 2: {\n            const label = labelToString(tree[1]);\n            const sub = hashTreeToString(tree[2]);\n            return `label(\\n label:\\n${indent(label)}\\n sub:\\n${indent(sub)}\\n)`;\n        }\n        case 3: {\n            return `leaf(...${tree[1].byteLength} bytes)`;\n        }\n        case 4: {\n            return `pruned(${blobToHex(blobFromUint8Array(new Uint8Array(tree[1])))}`;\n        }\n        default: {\n            return `unknown(${JSON.stringify(tree[0])})`;\n        }\n    }\n}\nfunction isBufferEqual(a, b) {\n    if (a.length !== b.length) {\n        return false;\n    }\n    for (let i = 0; i < a.length; i++) {\n        if (a[i] !== b[i]) {\n            return false;\n        }\n    }\n    return true;\n}\nexport class Certificate {\n    constructor(response, _agent = getDefaultAgent()) {\n        this._agent = _agent;\n        this.verified = false;\n        this._rootKey = null;\n        this.cert = cbor.decode(response.certificate);\n    }\n    lookupEx(path) {\n        this.checkState();\n        return lookupPathEx(path, this.cert.tree);\n    }\n    lookup(path) {\n        this.checkState();\n        return lookup_path(path, this.cert.tree);\n    }\n    async verify() {\n        const rootHash = await reconstruct(this.cert.tree);\n        const derKey = await this._checkDelegation(this.cert.delegation);\n        const sig = this.cert.signature;\n        const key = extractDER(derKey);\n        const msg = Buffer.concat([domain_sep('ic-state-root'), rootHash]);\n        const res = await blsVerify(key, sig, msg);\n        this.verified = res;\n        return res;\n    }\n    checkState() {\n        if (!this.verified) {\n            throw new UnverifiedCertificateError();\n        }\n    }\n    async _checkDelegation(d) {\n        if (!d) {\n            if (!this._rootKey) {\n                if (this._agent.rootKey) {\n                    this._rootKey = this._agent.rootKey;\n                    return this._rootKey;\n                }\n                throw new Error(`Agent does not have a rootKey. Do you need to call 'fetchRootKey'?`);\n            }\n            return this._rootKey;\n        }\n        const cert = new Certificate(d, this._agent);\n        if (!(await cert.verify())) {\n            throw new Error('fail to verify delegation certificate');\n        }\n        const lookup = cert.lookupEx(['subnet', d.subnet_id, 'public_key']);\n        if (!lookup) {\n            throw new Error(`Could not find subnet key for subnet 0x${d.subnet_id.toString('hex')}`);\n        }\n        return Buffer.from(lookup);\n    }\n}\nconst DER_PREFIX = Buffer.from('308182301d060d2b0601040182dc7c0503010201060c2b0601040182dc7c05030201036100', 'hex');\nconst KEY_LENGTH = 96;\nfunction extractDER(buf) {\n    const expectedLength = DER_PREFIX.length + KEY_LENGTH;\n    if (buf.length !== expectedLength) {\n        throw new TypeError(`BLS DER-encoded public key must be ${expectedLength} bytes long`);\n    }\n    const prefix = buf.slice(0, DER_PREFIX.length);\n    if (!isBufferEqual(prefix, DER_PREFIX)) {\n        throw new TypeError(`BLS DER-encoded public key is invalid. Expect the following prefix: ${DER_PREFIX}, but get ${prefix}`);\n    }\n    return buf.slice(DER_PREFIX.length);\n}\n/**\n * @param t\n */\nexport async function reconstruct(t) {\n    switch (t[0]) {\n        case 0 /* Empty */:\n            return hash(domain_sep('ic-hashtree-empty'));\n        case 4 /* Pruned */:\n            return Buffer.from(t[1]);\n        case 3 /* Leaf */:\n            return hash(Buffer.concat([\n                domain_sep('ic-hashtree-leaf'),\n                Buffer.from(t[1]),\n            ]));\n        case 2 /* Labeled */:\n            return hash(Buffer.concat([\n                domain_sep('ic-hashtree-labeled'),\n                Buffer.from(t[1]),\n                Buffer.from(await reconstruct(t[2])),\n            ]));\n        case 1 /* Fork */:\n            return hash(Buffer.concat([\n                domain_sep('ic-hashtree-fork'),\n                Buffer.from(await reconstruct(t[1])),\n                Buffer.from(await reconstruct(t[2])),\n            ]));\n        default:\n            throw new Error('unreachable');\n    }\n}\nfunction domain_sep(s) {\n    const buf = Buffer.alloc(1);\n    buf.writeUInt8(s.length, 0);\n    return Buffer.concat([buf, Buffer.from(s)]);\n}\n/**\n *\n * @param path\n * @param tree\n */\nexport function lookupPathEx(path, tree) {\n    const maybeReturn = lookup_path(path.map(p => {\n        if (typeof p === 'string') {\n            return blobFromText(p);\n        }\n        else {\n            return blobFromUint8Array(new Uint8Array(p));\n        }\n    }), tree);\n    return maybeReturn && blobToUint8Array(blobFromBuffer(maybeReturn));\n}\n/**\n * @param path\n * @param tree\n */\nexport function lookup_path(path, tree) {\n    if (path.length === 0) {\n        switch (tree[0]) {\n            case 3 /* Leaf */: {\n                return Buffer.from(tree[1]);\n            }\n            default: {\n                return undefined;\n            }\n        }\n    }\n    const t = find_label(path[0], flatten_forks(tree));\n    if (t) {\n        return lookup_path(path.slice(1), t);\n    }\n}\nfunction flatten_forks(t) {\n    switch (t[0]) {\n        case 0 /* Empty */:\n            return [];\n        case 1 /* Fork */:\n            return flatten_forks(t[1]).concat(flatten_forks(t[2]));\n        default:\n            return [t];\n    }\n}\nfunction find_label(l, trees) {\n    if (trees.length === 0) {\n        return undefined;\n    }\n    for (const t of trees) {\n        if (t[0] === 2 /* Labeled */) {\n            const p = Buffer.from(t[1]);\n            if (isBufferEqual(l, p)) {\n                return t[2];\n            }\n        }\n    }\n}\n//# sourceMappingURL=certificate.js.map","import { RequestStatusResponseStatus } from '../agent';\nimport { Certificate } from '../certificate';\nimport { toHex as requestIdToHex } from '../request_id';\nimport { blobFromText } from '@dfinity/candid';\nexport * as strategy from './strategy';\nexport { defaultStrategy } from './strategy';\n/**\n * Polls the IC to check the status of the given request then\n * returns the response bytes once the request has been processed.\n * @param agent The agent to use to poll read_state.\n * @param canisterId The effective canister ID.\n * @param requestId The Request ID to poll status for.\n * @param strategy A polling strategy.\n */\nexport async function pollForResponse(agent, canisterId, requestId, strategy) {\n    const path = [blobFromText('request_status'), requestId];\n    const state = await agent.readState(canisterId, { paths: [path] });\n    const cert = new Certificate(state, agent);\n    const verified = await cert.verify();\n    if (!verified) {\n        throw new Error('Fail to verify certificate');\n    }\n    const maybeBuf = cert.lookup([...path, blobFromText('status')]);\n    let status;\n    if (typeof maybeBuf === 'undefined') {\n        // Missing requestId means we need to wait\n        status = RequestStatusResponseStatus.Unknown;\n    }\n    else {\n        status = maybeBuf.toString();\n    }\n    switch (status) {\n        case RequestStatusResponseStatus.Replied: {\n            return cert.lookup([...path, blobFromText('reply')]);\n        }\n        case RequestStatusResponseStatus.Received:\n        case RequestStatusResponseStatus.Unknown:\n        case RequestStatusResponseStatus.Processing:\n            // Execute the polling strategy, then retry.\n            await strategy(canisterId, requestId, status);\n            return pollForResponse(agent, canisterId, requestId, strategy);\n        case RequestStatusResponseStatus.Rejected: {\n            const rejectCode = cert.lookup([...path, blobFromText('reject_code')]).toString();\n            const rejectMessage = cert.lookup([...path, blobFromText('reject_message')]).toString();\n            throw new Error(`Call was rejected:\\n` +\n                `  Request ID: ${requestIdToHex(requestId)}\\n` +\n                `  Reject code: ${rejectCode}\\n` +\n                `  Reject text: ${rejectMessage}\\n`);\n        }\n        case RequestStatusResponseStatus.Done:\n            // This is _technically_ not an error, but we still didn't see the `Replied` status so\n            // we don't know the result and cannot decode it.\n            throw new Error(`Call was marked as done but we never saw the reply:\\n` +\n                `  Request ID: ${requestIdToHex(requestId)}\\n`);\n    }\n    throw new Error('unreachable');\n}\n//# sourceMappingURL=index.js.map","import { Buffer } from 'buffer/';\nimport { getDefaultAgent, ReplicaRejectCode, } from './agent';\nimport { getManagementCanister } from './canisters/management';\nimport { AgentError } from './errors';\nimport { IDL } from '@dfinity/candid';\nimport { pollForResponse, strategy } from './polling';\nimport { Principal } from '@dfinity/principal';\nimport { toHex as requestIdToHex } from './request_id';\nexport class ActorCallError extends AgentError {\n    constructor(canisterId, methodName, type, props) {\n        super([\n            `Call failed:`,\n            `  Canister: ${canisterId.toText()}`,\n            `  Method: ${methodName} (${type})`,\n            ...Object.getOwnPropertyNames(props).map(n => `  \"${n}\": ${JSON.stringify(props[n])}`),\n        ].join('\\n'));\n        this.canisterId = canisterId;\n        this.methodName = methodName;\n        this.type = type;\n        this.props = props;\n    }\n}\nexport class QueryCallRejectedError extends ActorCallError {\n    constructor(canisterId, methodName, result) {\n        var _a;\n        super(canisterId, methodName, 'query', {\n            Status: result.status,\n            Code: (_a = ReplicaRejectCode[result.reject_code]) !== null && _a !== void 0 ? _a : `Unknown Code \"${result.reject_code}\"`,\n            Message: result.reject_message,\n        });\n        this.result = result;\n    }\n}\nexport class UpdateCallRejectedError extends ActorCallError {\n    constructor(canisterId, methodName, requestId, response) {\n        super(canisterId, methodName, 'update', {\n            'Request ID': requestIdToHex(requestId),\n            'HTTP status code': response.status.toString(),\n            'HTTP status text': response.statusText,\n        });\n        this.requestId = requestId;\n        this.response = response;\n    }\n}\n/**\n * The mode used when installing a canister.\n */\nexport var CanisterInstallMode;\n(function (CanisterInstallMode) {\n    CanisterInstallMode[\"Install\"] = \"install\";\n    CanisterInstallMode[\"Reinstall\"] = \"reinstall\";\n    CanisterInstallMode[\"Upgrade\"] = \"upgrade\";\n})(CanisterInstallMode || (CanisterInstallMode = {}));\nconst metadataSymbol = Symbol.for('ic-agent-metadata');\n/**\n * An actor base class. An actor is an object containing only functions that will\n * return a promise. These functions are derived from the IDL definition.\n */\nexport class Actor {\n    constructor(metadata) {\n        this[metadataSymbol] = Object.freeze(metadata);\n    }\n    /**\n     * Get the Agent class this Actor would call, or undefined if the Actor would use\n     * the default agent (global.ic.agent).\n     * @param actor The actor to get the agent of.\n     */\n    static agentOf(actor) {\n        return actor[metadataSymbol].config.agent;\n    }\n    /**\n     * Get the interface of an actor, in the form of an instance of a Service.\n     * @param actor The actor to get the interface of.\n     */\n    static interfaceOf(actor) {\n        return actor[metadataSymbol].service;\n    }\n    static canisterIdOf(actor) {\n        return Principal.from(actor[metadataSymbol].config.canisterId);\n    }\n    static async install(fields, config) {\n        const mode = fields.mode === undefined ? CanisterInstallMode.Install : fields.mode;\n        // Need to transform the arg into a number array.\n        const arg = fields.arg ? [...fields.arg] : [];\n        // Same for module.\n        const wasmModule = [...fields.module];\n        const canisterId = typeof config.canisterId === 'string'\n            ? Principal.fromText(config.canisterId)\n            : config.canisterId;\n        await getManagementCanister(config).install_code({\n            mode: { [mode]: null },\n            arg,\n            wasm_module: wasmModule,\n            canister_id: canisterId,\n        });\n    }\n    static async createCanister(config) {\n        const { canister_id: canisterId } = await getManagementCanister(config || {}).provisional_create_canister_with_cycles({ amount: [], settings: [] });\n        return canisterId;\n    }\n    static async createAndInstallCanister(interfaceFactory, fields, config) {\n        const canisterId = await this.createCanister(config);\n        await this.install(Object.assign({}, fields), Object.assign(Object.assign({}, config), { canisterId }));\n        return this.createActor(interfaceFactory, Object.assign(Object.assign({}, config), { canisterId }));\n    }\n    static createActorClass(interfaceFactory) {\n        const service = interfaceFactory({ IDL });\n        class CanisterActor extends Actor {\n            constructor(config) {\n                const canisterId = typeof config.canisterId === 'string'\n                    ? Principal.fromText(config.canisterId)\n                    : config.canisterId;\n                super({\n                    config: Object.assign(Object.assign(Object.assign({}, DEFAULT_ACTOR_CONFIG), config), { canisterId }),\n                    service,\n                });\n                for (const [methodName, func] of service._fields) {\n                    this[methodName] = _createActorMethod(this, methodName, func);\n                }\n            }\n        }\n        return CanisterActor;\n    }\n    static createActor(interfaceFactory, configuration) {\n        return new (this.createActorClass(interfaceFactory))(configuration);\n    }\n}\n// IDL functions can have multiple return values, so decoding always\n// produces an array. Ensure that functions with single or zero return\n// values behave as expected.\nfunction decodeReturnValue(types, msg) {\n    const returnValues = IDL.decode(types, Buffer.from(msg));\n    switch (returnValues.length) {\n        case 0:\n            return undefined;\n        case 1:\n            return returnValues[0];\n        default:\n            return returnValues;\n    }\n}\nconst DEFAULT_ACTOR_CONFIG = {\n    pollingStrategyFactory: strategy.defaultStrategy,\n};\nfunction _createActorMethod(actor, methodName, func) {\n    let caller;\n    if (func.annotations.includes('query')) {\n        caller = async (options, ...args) => {\n            var _a, _b;\n            // First, if there's a config transformation, call it.\n            options = Object.assign(Object.assign({}, options), (_b = (_a = actor[metadataSymbol].config).queryTransform) === null || _b === void 0 ? void 0 : _b.call(_a, methodName, args, Object.assign(Object.assign({}, actor[metadataSymbol].config), options)));\n            const agent = options.agent || actor[metadataSymbol].config.agent || getDefaultAgent();\n            const cid = Principal.from(options.canisterId || actor[metadataSymbol].config.canisterId);\n            const arg = IDL.encode(func.argTypes, args);\n            const result = await agent.query(cid, { methodName, arg });\n            switch (result.status) {\n                case \"rejected\" /* Rejected */:\n                    throw new QueryCallRejectedError(cid, methodName, result);\n                case \"replied\" /* Replied */:\n                    return decodeReturnValue(func.retTypes, result.reply.arg);\n            }\n        };\n    }\n    else {\n        caller = async (options, ...args) => {\n            var _a, _b;\n            // First, if there's a config transformation, call it.\n            options = Object.assign(Object.assign({}, options), (_b = (_a = actor[metadataSymbol].config).callTransform) === null || _b === void 0 ? void 0 : _b.call(_a, methodName, args, Object.assign(Object.assign({}, actor[metadataSymbol].config), options)));\n            const agent = options.agent || actor[metadataSymbol].config.agent || getDefaultAgent();\n            const { canisterId, effectiveCanisterId, pollingStrategyFactory } = Object.assign(Object.assign(Object.assign({}, DEFAULT_ACTOR_CONFIG), actor[metadataSymbol].config), options);\n            const cid = Principal.from(canisterId);\n            const ecid = effectiveCanisterId !== undefined ? Principal.from(effectiveCanisterId) : cid;\n            const arg = IDL.encode(func.argTypes, args);\n            const { requestId, response } = await agent.call(cid, {\n                methodName,\n                arg,\n                effectiveCanisterId: ecid,\n            });\n            if (!response.ok) {\n                throw new UpdateCallRejectedError(cid, methodName, requestId, response);\n            }\n            const pollStrategy = pollingStrategyFactory();\n            const responseBytes = await pollForResponse(agent, ecid, requestId, pollStrategy);\n            if (responseBytes !== undefined) {\n                return decodeReturnValue(func.retTypes, responseBytes);\n            }\n            else if (func.retTypes.length === 0) {\n                return undefined;\n            }\n            else {\n                throw new Error(`Call was returned undefined, but type [${func.retTypes.join(',')}].`);\n            }\n        };\n    }\n    const handler = (...args) => caller({}, ...args);\n    handler.withOptions =\n        (options) => (...args) => caller(options, ...args);\n    return handler;\n}\n//# sourceMappingURL=actor.js.map","import { toHex } from '..';\nconst FIVE_MINUTES_IN_MSEC = 5 * 60 * 1000;\n/**\n * A best practices polling strategy: wait 2 seconds before the first poll, then 1 second\n * with an exponential backoff factor of 1.2. Timeout after 5 minutes.\n */\nexport function defaultStrategy() {\n    return chain(conditionalDelay(once(), 1000), backoff(1000, 1.2), timeout(FIVE_MINUTES_IN_MSEC));\n}\n/**\n * Predicate that returns true once.\n */\nexport function once() {\n    let first = true;\n    return async () => {\n        if (first) {\n            first = false;\n            return true;\n        }\n        return false;\n    };\n}\n/**\n * Delay the polling once.\n * @param condition A predicate that indicates when to delay.\n * @param timeInMsec The amount of time to delay.\n */\nexport function conditionalDelay(condition, timeInMsec) {\n    return async (canisterId, requestId, status) => {\n        if (await condition(canisterId, requestId, status)) {\n            return new Promise(resolve => setTimeout(resolve, timeInMsec));\n        }\n    };\n}\n/**\n * Error out after a maximum number of polling has been done.\n * @param count The maximum attempts to poll.\n */\nexport function maxAttempts(count) {\n    let attempts = count;\n    return async (canisterId, requestId, status) => {\n        if (--attempts <= 0) {\n            throw new Error(`Failed to retrieve a reply for request after ${count} attempts:\\n` +\n                `  Request ID: ${toHex(requestId)}\\n` +\n                `  Request status: ${status}\\n`);\n        }\n    };\n}\n/**\n * Throttle polling.\n * @param throttleInMsec Amount in millisecond to wait between each polling.\n */\nexport function throttle(throttleInMsec) {\n    return () => new Promise(resolve => setTimeout(resolve, throttleInMsec));\n}\n/**\n * Reject a call after a certain amount of time.\n * @param timeInMsec Time in milliseconds before the polling should be rejected.\n */\nexport function timeout(timeInMsec) {\n    const end = Date.now() + timeInMsec;\n    return async (canisterId, requestId, status) => {\n        if (Date.now() > end) {\n            throw new Error(`Request timed out after ${timeInMsec} msec:\\n` +\n                `  Request ID: ${toHex(requestId)}\\n` +\n                `  Request status: ${status}\\n`);\n        }\n    };\n}\n/**\n * A strategy that throttle, but using an exponential backoff strategy.\n * @param startingThrottleInMsec The throttle in milliseconds to start with.\n * @param backoffFactor The factor to multiple the throttle time between every poll. For\n *   example if using 2, the throttle will double between every run.\n */\nexport function backoff(startingThrottleInMsec, backoffFactor) {\n    let currentThrottling = startingThrottleInMsec;\n    return () => new Promise(resolve => setTimeout(() => {\n        currentThrottling *= backoffFactor;\n        resolve();\n    }, currentThrottling));\n}\n/**\n * Chain multiple polling strategy. This _chains_ the strategies, so if you pass in,\n * say, two throttling strategy of 1 second, it will result in a throttle of 2 seconds.\n * @param strategies A strategy list to chain.\n */\nexport function chain(...strategies) {\n    return async (canisterId, requestId, status) => {\n        for (const a of strategies) {\n            await a(canisterId, requestId, status);\n        }\n    };\n}\n//# sourceMappingURL=strategy.js.map","export default ({ IDL }) => {\n  return IDL.Service({ 'greet' : IDL.Func([IDL.Text], [IDL.Text], []) });\n};\nexport const init = ({ IDL }) => { return []; };","import idlImport from './ic_demo.did.js';\nexport const idlFactory = idlImport;\nexport const canisterId = \"2i7bu-aiaaa-aaaah-aag7a-cai\";\n","import { Actor, HttpAgent } from '@dfinity/agent';\nimport { idlFactory as ic_demo_idl, canisterId as ic_demo_id } from 'dfx-generated/ic_demo';\n\nconst agent = new HttpAgent();\nconst ic_demo = Actor.createActor(ic_demo_idl, { agent, canisterId: ic_demo_id });\n\ndocument.getElementById(\"clickMeBtn\").addEventListener(\"click\", async () => {\n  const name = document.getElementById(\"name\").value.toString();\n  const greeting = await ic_demo.greet(name);\n\n  document.getElementById(\"greeting\").innerText = greeting;\n});\n"],"sourceRoot":""}