{"version":3,"sources":["webpack://icp_bunny_assets/./node_modules/@dfinity/agent/node_modules/buffer/index.js","webpack://icp_bunny_assets/./node_modules/base64-arraybuffer/lib/base64-arraybuffer.js","webpack://icp_bunny_assets/./node_modules/base64-js/index.js","webpack://icp_bunny_assets/./node_modules/bignumber.js/bignumber.js","webpack://icp_bunny_assets/./node_modules/borc/node_modules/buffer/index.js","webpack://icp_bunny_assets/./node_modules/borc/src/constants.js","webpack://icp_bunny_assets/./node_modules/borc/src/decoder.asm.js","webpack://icp_bunny_assets/./node_modules/borc/src/decoder.js","webpack://icp_bunny_assets/./node_modules/borc/src/diagnose.js","webpack://icp_bunny_assets/./node_modules/borc/src/encoder.js","webpack://icp_bunny_assets/./node_modules/borc/src/index.js","webpack://icp_bunny_assets/./node_modules/borc/src/simple.js","webpack://icp_bunny_assets/./node_modules/borc/src/tagged.js","webpack://icp_bunny_assets/./node_modules/borc/src/utils.js","webpack://icp_bunny_assets/./node_modules/buffer-pipe/index.js","webpack://icp_bunny_assets/./node_modules/buffer/index.js","webpack://icp_bunny_assets/./node_modules/ieee754/index.js","webpack://icp_bunny_assets/./node_modules/iso-url/index.js","webpack://icp_bunny_assets/./node_modules/iso-url/src/relative.js","webpack://icp_bunny_assets/./node_modules/iso-url/src/url-browser.js","webpack://icp_bunny_assets/./node_modules/js-sha256/src/sha256.js","webpack://icp_bunny_assets/./node_modules/process/browser.js","webpack://icp_bunny_assets/./node_modules/safe-buffer/index.js","webpack://icp_bunny_assets/./node_modules/simple-cbor/src/index.js","webpack://icp_bunny_assets/./node_modules/simple-cbor/src/serializer.js","webpack://icp_bunny_assets/./node_modules/simple-cbor/src/value.js","webpack://icp_bunny_assets/webpack/bootstrap","webpack://icp_bunny_assets/webpack/runtime/amd options","webpack://icp_bunny_assets/webpack/runtime/compat get default export","webpack://icp_bunny_assets/webpack/runtime/define property getters","webpack://icp_bunny_assets/webpack/runtime/global","webpack://icp_bunny_assets/webpack/runtime/hasOwnProperty shorthand","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/utils/leb128.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/types.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/utils/base32.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/utils/getCrc.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/principal.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/utils/sha224.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/auth.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/cbor.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/agent/http/transforms.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/agent/http/types.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/agent/http/index.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/agent/proxy.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/vendor/bls/bls.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/certificate.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/idl.js","webpack://icp_bunny_assets/./node_modules/@dfinity/agent/lib/esm/actor.js","webpack://icp_bunny_assets/./src/3d_icpbunny/src/index.js"],"names":["base64","ieee754","customInspectSymbol","Symbol","exports","Buffer","K_MAX_LENGTH","createBuffer","length","RangeError","buf","Uint8Array","Object","setPrototypeOf","prototype","arg","encodingOrOffset","TypeError","allocUnsafe","from","value","string","encoding","isEncoding","byteLength","actual","write","slice","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","obj","isBuffer","len","checked","undefined","numberIsNaN","type","Array","isArray","data","fromObject","toPrimitive","assertSize","size","array","i","toString","mustMatch","arguments","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","this","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","bidirectionalIndexOf","val","dir","arrayIndexOf","indexOf","call","lastIndexOf","arr","indexSize","arrLength","valLength","String","read","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","push","charCodeAt","asciiToBytes","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","fromByteArray","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","proto","foo","e","typedArraySupport","console","error","defineProperty","enumerable","get","poolSize","alloc","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","set","swap16","swap32","swap64","toLocaleString","equals","inspect","max","replace","trim","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","Error","toJSON","_arr","ret","out","hexSliceLookupTable","bytes","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","pow","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","code","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","split","base64clean","src","dst","constructor","name","alphabet","table","i16","chars","lookup","encode","arraybuffer","substring","decode","encoded1","encoded2","encoded3","encoded4","bufferLength","p","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","maxChunkLength","len2","encodeChunk","join","num","output","globalObject","BigNumber","isNumeric","mathceil","ceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","coeffToString","s","z","r","xc","yc","k","l","intCheck","isOdd","toExponential","charAt","toFixedPoint","zs","clone","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","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","caseChanged","isNum","_isBigNumber","test","search","round","DEBUG","toUpperCase","format","rm","id","c0","ne","maxOrMin","args","method","normalise","pop","sd","d","ni","rd","pows10","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","lt","minimum","gt","random","dp","rand","Uint32Array","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","reverse","sign","callerIsToString","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","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","g1","g2","intPart","fractionPart","isNeg","intDigits","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","SlowBuffer","INSPECT_MAX_BYTES","kMaxLength","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","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","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","pipe","shift","getLowerBytes","blobFromHex","lookupTable","lookUpTable","_blob","_isPrincipal","publicKey","sha","shaObj","other","fromText","text","skip","decodeChar","char","principal","toText","blob","isAnonymous","toBlob","toHash","toHex","checksumArrayBuf","crc","checksum","matches","bits","TextEncoder","serializer","CborTag","SubmitRequestType","RequestStatusResponseStatus","ProxyMessageKind","wasmBytesBase64","Type","display","valueToString","buildTypeTable","typeTable","has","_buildTypeTableImpl","PrimitiveType","checkType","ConstructType","RecClass","ty","getType","encodeType","isValidUTF8","FloatClass","_bits","accept","visitFloat","covariant","encodeValue","decodeValue","FixedIntClass","visitFixedInt","log2","FixedNatClass","visitFixedNat","_id","_counter","_type","visitRec","merge","decodePrincipalId","visitEmpty","visitReserved","visitBool","visitNull","visitText","visitInt","pipeView","visitNat","visitPrincipal","CanisterInstallMode","for","bunnyFactory","IDL","Property","Record","Text","MintRequest","Vec","Nat8","Service","Func","Nat64","Nat","Principal","connectionState","ic","plug","requestConnect","bunnyCanisterId","whitelist","principalId","agent","getPrincipal","document","createElement","setAttribute","innerHTML","b1","getElementById","appendChild","bunnyActor","createActor","canisterId","interfaceFactory","myTokens","user_tokens","remove"],"mappings":"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EAC,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,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GAEA8G,GAEAC,GAEAC,GAEAC,GACA2B,GACAA,GACAA,GAEA1B,GAEAC,GAEAA,GAEAA,GAEAA,GAEAA,GAEAA,GAEAK,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GAEAA,GACAA,GACAA,GAEAI,GACAC,GACAC,GACAC,GACAa,GACAA,GACAA,GACAA,GAEAZ,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GACAA,GAEAC,GAEAC,GAEAC,GAEAC,GAEAC,GAEAC,GAEAI,GAEAC,GACAC,GAC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","file":"index.js","sourcesContent":["/*!\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","/*\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))","import Pipe from 'buffer-pipe';\nimport { Buffer } from 'buffer/';\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 shift = BigInt(0);\n    let value = BigInt(0);\n    let byte;\n    do {\n        byte = safeRead(pipe, 1)[0];\n        value += BigInt(byte & 0x7f).valueOf() * BigInt(2) ** shift;\n        shift += BigInt(7);\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}\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}\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}\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}\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","import { 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}\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","// 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,\n    0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,\n    0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,\n    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,\n    0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,\n    0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,\n    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,\n    0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,\n    0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,\n    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,\n    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,\n    0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,\n    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,\n    0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,\n    0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,\n    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,\n    0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,\n    0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,\n    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,\n    0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,\n    0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,\n    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,\n    0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,\n    0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,\n    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,\n    0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,\n    0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,\n    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,\n    0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,\n    0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,\n    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,\n    0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,\n    0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,\n    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,\n    0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,\n    0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,\n    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,\n    0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,\n    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,\n    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,\n    0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,\n    0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,\n    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,\n    0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,\n    0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,\n    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,\n    0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,\n    0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,\n    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,\n    0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,\n    0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,\n    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,\n    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,\n    0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,\n    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,\n    0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,\n    0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,\n    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,\n    0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,\n    0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,\n    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,\n    0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,\n    0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,\n    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D,\n]);\n/**\n * Calculate the CRC32 of a blob.\n * @param buf The blob 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 { Buffer } from 'buffer/';\nimport { blobFromHex, blobFromUint8Array, blobToHex } from './types';\nimport { decode, encode } from './utils/base32';\nimport { getCrc32 } from './utils/getCrc';\nimport { sha224 } from './utils/sha224';\nconst SELF_AUTHENTICATING_SUFFIX = 2;\nconst ANONYMOUS_SUFFIX = 4;\nexport class Principal {\n    constructor(_blob) {\n        this._blob = _blob;\n        this._isPrincipal = true;\n    }\n    static anonymous() {\n        return new this(blobFromUint8Array(new Uint8Array([ANONYMOUS_SUFFIX])));\n    }\n    static selfAuthenticating(publicKey) {\n        const sha = sha224(publicKey);\n        return new this(blobFromUint8Array(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._blob);\n        }\n        throw new Error(`Impossible to convert ${JSON.stringify(other)} to Principal.`);\n    }\n    static fromHex(hex) {\n        return new this(blobFromHex(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(blobFromUint8Array(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 fromBlob(blob) {\n        return new this(blob);\n    }\n    isAnonymous() {\n        return this._blob.byteLength === 1 && this._blob[0] === ANONYMOUS_SUFFIX;\n    }\n    toBlob() {\n        return this._blob;\n    }\n    toHash() {\n        return this._blob;\n    }\n    toHex() {\n        return blobToHex(this._blob).toUpperCase();\n    }\n    toText() {\n        const checksumArrayBuf = new ArrayBuffer(4);\n        const view = new DataView(checksumArrayBuf);\n        view.setUint32(0, getCrc32(this.toBlob()), false);\n        const checksum = Uint8Array.from(Buffer.from(checksumArrayBuf));\n        const bytes = Uint8Array.from(this._blob);\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=principal.js.map","import { sha224 as jsSha224 } from 'js-sha256';\nimport { blobFromUint8Array } from '../types';\nexport function sha224(data) {\n    const shaObj = jsSha224.create();\n    shaObj.update(data);\n    return blobFromUint8Array(new Uint8Array(shaObj.array()));\n}\n//# sourceMappingURL=sha224.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 './principal';\nimport { requestIdOf } from './request_id';\nimport { blobFromBuffer } from './types';\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        return Principal.selfAuthenticating(this.getPublicKey().toDer());\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 './types';\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.toBlob());\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 } from '../../types';\nimport { lebEncode } from '../../utils/leb128';\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 = (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 '../../principal';\nimport { requestIdOf } from '../../request_id';\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;\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        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) {\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) {\n            // Safe to ignore here.\n            this._host = options.source._host;\n        }\n        else {\n            const location = window === null || window === void 0 ? void 0 : window.location;\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 ? identity : this._identity);\n        const canister = Principal.from(canisterId);\n        const ecid = options.effectiveCanisterId\n            ? Principal.from(options.effectiveCanisterId)\n            : canister;\n        const sender = (id === null || id === void 0 ? void 0 : 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.toBlob(),\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 || 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.toBlob(),\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 || 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.toBlob(),\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    _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 '..';\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    }\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}\n//# sourceMappingURL=proxy.js.map","/* 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 = require('base64-arraybuffer').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 { Buffer } from 'buffer/';\nimport { getDefaultAgent } from './agent';\nimport * as cbor from './cbor';\nimport { hash } from './request_id';\nimport { blsVerify } from './utils/bls';\nasync function getRootKey(agent) {\n    // TODO add the real root key for Mercury\n    return (await agent.status()).root_key;\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    lookup(path) {\n        if (!this.verified) {\n            throw new Error('Cannot lookup unverified certificate');\n        }\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    async _checkDelegation(d) {\n        if (!d) {\n            if (!this._rootKey) {\n                this._rootKey = await getRootKey(this._agent);\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 res = cert.lookup([Buffer.from('subnet'), d.subnet_id, Buffer.from('public_key')]);\n        return Promise.resolve(res);\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 * @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","// tslint:disable:max-classes-per-file\nimport Pipe from 'buffer-pipe';\nimport { Buffer } from 'buffer/';\nimport { Principal as PrincipalId } from './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    }\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        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        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                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                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            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            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();\nexport function Tuple(...types) {\n    return new TupleClass(types);\n}\nexport function Vec(t) {\n    return new VecClass(t);\n}\nexport function Opt(t) {\n    return new OptClass(t);\n}\nexport function Record(t) {\n    return new RecordClass(t);\n}\nexport function Variant(fields) {\n    return new VariantClass(fields);\n}\nexport function Rec() {\n    return new RecClass();\n}\nexport function Func(args, ret, annotations = []) {\n    return new FuncClass(args, ret, annotations);\n}\nexport function Service(t) {\n    return new ServiceClass(t);\n}\n//# sourceMappingURL=idl.js.map","import { Buffer } from 'buffer/';\nimport { getDefaultAgent, RequestStatusResponseStatus } from './agent';\nimport { getManagementCanister } from './canisters/management';\nimport { Certificate } from './certificate';\nimport * as IDL from './idl';\nimport { Principal } from './principal';\nimport { toHex as requestIdToHex } from './request_id';\nimport { blobFromText } from './types';\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     */\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        const computerAllocation = fields.computerAllocation !== undefined ? [fields.computerAllocation] : [];\n        const memoryAllocation = fields.memoryAllocation !== undefined ? [fields.memoryAllocation] : [];\n        await getManagementCanister(config).install_code({\n            mode: { [mode]: null },\n            arg,\n            wasm_module: wasmModule,\n            canister_id: canisterId,\n            compute_allocation: computerAllocation,\n            memory_allocation: memoryAllocation,\n        });\n    }\n    static async createCanister(config) {\n        const { canister_id: canisterId } = await getManagementCanister(config || {})\n            .provisional_create_canister_with_cycles({ amount: [] });\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 REQUEST_STATUS_RETRY_WAIT_DURATION_IN_MSECS = 1000;\nconst DEFAULT_ACTOR_CONFIG = {\n    maxAttempts: 300,\n    throttleDurationInMSecs: REQUEST_STATUS_RETRY_WAIT_DURATION_IN_MSECS,\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 = 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 Error(`Query failed:\\n` +\n                        `  Status: ${result.status}\\n` +\n                        `  Message: ${result.reject_message}\\n`);\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, maxAttempts, throttleDurationInMSecs } = 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 Error([\n                    'Call failed:',\n                    `  Method: ${methodName}(${args})`,\n                    `  Canister ID: ${cid}`,\n                    `  Request ID: ${requestIdToHex(requestId)}`,\n                    `  HTTP status code: ${response.status}`,\n                    `  HTTP status text: ${response.statusText}`,\n                ].join('\\n'));\n            }\n            return _requestStatusAndLoop(agent, ecid, requestId, bytes => {\n                if (bytes !== undefined) {\n                    return decodeReturnValue(func.retTypes, bytes);\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            }, maxAttempts, maxAttempts, throttleDurationInMSecs);\n        };\n    }\n    const handler = (...args) => caller({}, ...args);\n    handler.withOptions = (options) => (...args) => caller(options, ...args);\n    return handler;\n}\nasync function _requestStatusAndLoop(agent, canisterId, requestId, decoder, attempts, maxAttempts, throttle) {\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            const response = cert.lookup([...path, blobFromText('reply')]);\n            return decoder(response);\n        }\n        case RequestStatusResponseStatus.Received:\n        case RequestStatusResponseStatus.Unknown:\n        case RequestStatusResponseStatus.Processing:\n            if (--attempts <= 0) {\n                throw new Error(`Failed to retrieve a reply for request after ${maxAttempts} attempts:\\n` +\n                    `  Request ID: ${requestIdToHex(requestId)}\\n` +\n                    `  Request status: ${status}\\n`);\n            }\n            // Wait a little, then retry.\n            return new Promise(resolve => setTimeout(resolve, throttle)).then(() => _requestStatusAndLoop(agent, canisterId, requestId, decoder, attempts, maxAttempts, throttle));\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=actor.js.map","import { Principal } from \"@dfinity/agent\"; \n\nconst bunnyFactory = ({ IDL }) => {\n    const Property = IDL.Record({ 'value' : IDL.Text, 'name' : IDL.Text });\n    const MintRequest_2 = IDL.Record({\n      'url' : IDL.Text,\n      'dataurl' : IDL.Text,\n      'accountid' : IDL.Text,\n      'contentType' : IDL.Text,\n      'data' : IDL.Vec(IDL.Nat8),\n      'desc' : IDL.Text,\n      'name' : IDL.Text,\n      'properties' : IDL.Vec(Property),\n    });\n    const MintRequest = MintRequest_2;\nreturn IDL.Service({\n    'getPrice' : IDL.Func([], [IDL.Nat64], []),\n    'getCurrentToken' : IDL.Func([], [IDL.Nat], ['query']),\n    'nextAccount' : IDL.Func([], [], []),\n    'claim' : IDL.Func([], [IDL.Nat], []),\n    'mint' : IDL.Func([MintRequest], [IDL.Nat], []),\n    'my_tokens' : IDL.Func([], [IDL.Vec(IDL.Nat)], []),\n    'user_tokens' : IDL.Func([IDL.Principal], [IDL.Vec(IDL.Nat)], ['query']),\n});\n};\n\n(async () => {\n\n\n    const result = await window.ic.plug.requestConnect();\n    const connectionState = result ? \"allowed\" : \"denied\";\n    console.log(`The Connection was ${connectionState}!`);\n\n\n    // Canister Ids\n    const bunnyCanisterId = 'xkbqi-2qaaa-aaaah-qbpqq-cai';\n\n    // Whitelist\n    const whitelist = [\n      bunnyCanisterId,\n    ];\n  \n    // Make the request\n    const isConnected = await window.ic.plug.requestConnect({\n      whitelist,\n    });\n  \n    // Get the user principal id\n    const principalId = await window.ic.plug.agent.getPrincipal();\n    console.log(`Plug's user principal Id is ${principalId}`);\n    \n    var a = document.createElement('a');\n    a.setAttribute('href',\"#\");\n    a.setAttribute('id',\"pleaselink\");\n    a.setAttribute('class',\"btn\");\n\n    a.innerHTML = \"Please wait...\";\n    const b1 = document.createElement('br');\n    const b2 = document.createElement('br');\n    b1.setAttribute('id',\"b1\");\n    b2.setAttribute('id',\"b2\");\n\n    document.getElementById('message2').appendChild(b1);             \n    document.getElementById('message2').appendChild(b2);             \n    document.getElementById('message2').appendChild(a);  \n\n    if(connectionState)\n    {\n  \n        // Create an actor to interact with the NNS Canister\n        // we pass the NNS Canister id and the interface factory\n        const bunnyActor = await window.ic.plug.createActor({\n        canisterId: bunnyCanisterId,\n        interfaceFactory: bunnyFactory,\n        });\n\n        let myTokens  = await bunnyActor.user_tokens(principalId);  \n        console.log(myTokens);\n\n        if(myTokens.length > 0)\n        {\n            document.getElementById('pleaselink').remove();\n            document.getElementById('b1').remove();\n            document.getElementById('b2').remove();\n\n\n            document.getElementById('isBunnyHolder').value = myTokens.length;\n\n            var a = document.createElement('a');\n            a.setAttribute('href',\"#\");\n            a.setAttribute('id',\"bunnylink\");\n            a.setAttribute('class',\"btn\");\n\n            a.innerHTML = \"Reveal 3D Bunny \";\n            const b1 = document.createElement('br');\n            const b2 = document.createElement('br');\n            b1.setAttribute('id',\"b1\");\n            b2.setAttribute('id',\"b2\");\n\n            document.getElementById('message2').appendChild(b1);             \n            document.getElementById('message2').appendChild(b2);             \n            document.getElementById('message2').appendChild(a);      \n\n            \n        }\n        else\n        {\n\n            document.getElementById('pleaselink').remove();\n            document.getElementById('b1').remove();\n            document.getElementById('b2').remove();\n\n            var img = document.createElement('img');\n\n\n            img.src = './resources/bunny.png';\n            \n            var a = document.createElement('a');\n            a.setAttribute('href',\"https://entrepot.app/marketplace/icpbunny\");\n            a.setAttribute('target',\"_\");\n            a.setAttribute('class',\"btn\");\n\n\n            a.innerHTML = \"To control 3D Bunny. You need atleast one Bunny in your wallet.Buy ICPBunny ! \";\n\n            const b1 = document.createElement('br');\n            const b2 = document.createElement('br');\n            b1.setAttribute('id',\"b1\");\n            b2.setAttribute('id',\"b2\");\n\n            //document.getElementById('image').appendChild(img); \n            document.getElementById('message').appendChild(b1);             \n            document.getElementById('message').appendChild(b2);             \n            document.getElementById('message').appendChild(a); \n            \n            document.getElementById('isBunnyHolder').value = 0;\n\n\n        }\n    }\n  })();\n\n/***************************************************/\n//Account ID\nasync function accountID()\n{\n  try {\n      const index = document.getElementById(\"account-index\").value.toString();\n      const bunnyPrincpal = \"vwwmp-om32r-tgzpy-3lx3m-a5qbm-5pst6-xfdoi-gtivj-trcp6-k3dch-5ae\";\n      const cont_principal = principalToAccountIdentifier(bunnyPrincpal,index);\n      document.getElementById(\"account-name\").value = cont_principal;\n      \n      // // console.log(cont_principal);\n    \n      connectWallet();\n  } catch (error) \n  {\n    console.error(error);\n  } \n\n}\n\nconst principalToAccountIdentifier = (p, s) => {\n  const padding = Buffer(\"\\x0Aaccount-id\");\n  const array = new Uint8Array([\n      ...padding,\n      ...Principal.fromText(p).toBlob(),\n      ...getSubAccountArray(s)\n  ]);\n  // console.log(\"Array Start\");\n  // console.log(array[array.length-1]);\n  // console.log(array[array.length-2]);\n  // console.log(\"Array End\");\n\n\n  const hash = sha224(array);\n  const checksum = to32bits(getCrc32(hash));\n  const array2 = new Uint8Array([\n      ...checksum,\n      ...hash\n  ]);\n  return toHexString(array2);\n};\n\nconst toHexString = (byteArray)  =>{\n  return Array.from(byteArray, function(byte) {\n    return ('0' + (byte & 0xFF).toString(16)).slice(-2);\n  }).join('')\n}\n\nconst getSubAccountArray = (s) => {\n  if (Array.isArray(s)){\n    return s.concat(Array(32-s.length).fill(0));\n  } else {\n    //32 bit number only\n    return Array(28).fill(0).concat(to32bits(s ? s : 0))\n  }\n};\n\n/***************************************************/\n\n\nasync function  connectWallet() \n{\n    // Canister Ids\n    const bunnyCanisterId = 'xkbqi-2qaaa-aaaah-qbpqq-cai';\n\n    // Whitelist\n    const whitelist = [\n      bunnyCanisterId,\n    ];\n  \n    // Make the request\n    const isConnected = await window.ic.plug.requestConnect({\n      whitelist,\n    });\n  \n    // Get the user principal id\n    const principalId = await window.ic.plug.agent.getPrincipal();\n  \n    console.log(`Plug's user principal Id is ${principalId}`);\n    \n    let userPrincipal = principalId; //Principal.fromText(principalId);\n\n    await window?.ic?.plug?.requestConnect({\n        bunnyCanisterId,\n        host:\"https://mainnet.dfinity.network\",\n      });\n    \n    // Create an actor to interact with the NNS Canister\n    // we pass the NNS Canister id and the interface factory\n    const bunnyActor = await window.ic.plug.createActor({\n      canisterId: bunnyCanisterId,\n      interfaceFactory: bunnyFactory,\n    });\n\n    let myTokens  = await bunnyActor.user_tokens(userPrincipal);  \n    \n    console.log(myTokens);\n\n}\n\n/*\n  document.getElementById(\"plugbutton\").addEventListener(\"click\", () => {\n    connectWallet();\n  });\n  */"],"sourceRoot":""}