@timestope-official/bitcoinkrypton-browser 0.0.1-0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (20) hide show
  1. package/README.md +72 -0
  2. package/VERSION +5 -0
  3. package/krypton.js +2 -0
  4. package/krypton.js.map +1 -0
  5. package/namespace.d.ts +8 -0
  6. package/package.json +41 -0
  7. package/types.d.ts +4353 -0
  8. package/web-babel.js +2 -0
  9. package/web-babel.js.map +1 -0
  10. package/web-offline.js +2 -0
  11. package/web-offline.js.map +1 -0
  12. package/web.esm.js +2 -0
  13. package/web.esm.js.map +1 -0
  14. package/web.js +2 -0
  15. package/web.js.map +1 -0
  16. package/worker-js.js +1 -0
  17. package/worker-wasm.js +1 -0
  18. package/worker-wasm.wasm +0 -0
  19. package/worker.js +2 -0
  20. package/worker.js.map +1 -0
package/worker.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"sources":["Class.js","LogNative.js","Log.js","IWorker.js","CryptoUtils.js","CryptoWorker.js","CryptoWorkerImpl.js","BigNumber.js","NumberUtils.js","BufferUtils.js","SerialBuffer.js","MinerWorker.js","MinerWorkerImpl.js","MinerWorkerPool.js","PlatformUtils.js","WasmHelper.js","GenesisConfig.js","ArrayUtils.js","Assert.js","MerkleTree.js","MerklePath.js","Policy.js","Serializable.js","Hash.js","PublicKey.js","Signature.js","Address.js","Bech32.js","Account.js","PrunedAccount.js","BasicAccount.js","Contract.js","HashedTimeLockedContract.js","VestingContract.js","BlockHeader.js","BlockInterlink.js","BlockBody.js","BlockUtils.js","Block.js","Transaction.js","SignatureProof.js","BasicTransaction.js","ExtendedTransaction.js"],"names":["Class","scope","exports","self","window","[object Object]","cls","name","register","LogNative","this","_global_level","Log","INFO","_tag_levels","localStorage","c","getItem","JSON","parse","e","console","warn","tag","level","setItem","stringify","args","isLoggable","unshift","Level","toStringTag","Date","toTimeString","substr","error","ERROR","apply","WARNING","info","debug","DEBUG","trace","TRACE","log","instance","_instance","native","_native","setLoggable","get","l","i","length","toString","constructor","msg","message","arguments","Array","prototype","slice","call","undefined","VERBOSE","ASSERT","v","isNaN","parseInt","toLowerCase","d","bind","w","t","IWorker","clazz","worker","Proxy","workerScript","_workersSupported","Krypton","_path","createProxy","Worker","URL","createObjectURL","Blob","replace","_workerImplementation","init","size","Pool","startWorkerForProxy","start","data","command","res","postMessage","status","result","id","areWorkersAsync","_insideWebWorker","WorkerGlobalScope","_global","global","baseClazz","impl","onmessage","stubBaseOnMessage","url","resolve","head","document","getElementsByTagName","script","createElement","type","src","ret","setTimeout","onreadystatechange","onload","appendChild","proxyClass","super","_name","_messageId","_worker","_receive","_waiting","Map","_invoke","then","cb","delete","WorkerProxy","Promise","obj","set","funcName","Object","getOwnPropertyNames","Stub","finalRes","_result","_onmessage","close","poolClass","proxyInitializer","_proxyInitializer","_poolSize","_workers","_freeWorkers","_waitingCalls","_updateToSize","poolSize","_size","catch","push","shift","_step","indexOf","destroy","workerPromises","createdWorkers","all","pop","idx","splice","_moduleLoadedCallbacks","CryptoUtils","key","SHA512_BLOCK_SIZE","SerialBuffer","Hash","computeSha512","iKey","oKey","byte","innerHash","BufferUtils","concatTypedArrays","password","salt","iterations","derivedKeyLength","hashLength","SIZE","Algorithm","SHA512","Math","pow","Error","ceil","r","derivedKey","u","write","writeUint32","computeHmacSha512","j","k","CryptoWorker","getInstanceAsync","kdfLegacy","byteLength","xor","kdf","lib","CryptoLib","_workerAsync","startWorkerPoolForProxy","input","inputs","outputSize","block","transactionValid","timeNow","genesisHash","networkId","CryptoWorkerImpl","_superInit","PlatformUtils","isBrowser","WasmHelper","doImportBrowser","isNodeJs","out","Uint8Array","getSize","ARGON2D","NodeNative","node_argon2","stackPtr","Module","stackSave","hashSize","wasmOut","stackAlloc","wasmIn","HEAPU8","buffer","_krypton_argon2","hash","stackRestore","hashes","stackTmp","node_kdf_legacy","wasmSalt","_krypton_kdf_legacy","node_kdf","_krypton_kdf","blockSerialized","GenesisConfig","GENESIS_HASH","unserialize","NETWORK_ID","Block","body","transactions","_valid","valid","_verify","header","interlinkHash","interlink","bodyHash","serialize","prepareForWorkerUse","globalObject","BigNumber","isNumeric","mathceil","mathfloor","floor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","n","coeffToString","a","s","z","charCodeAt","compare","x","y","b","xc","yc","intCheck","min","max","isArray","isOdd","toExponential","str","charAt","toFixedPoint","len","zs","clone","configObject","div","convertBase","parseNumeric","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","valueOf","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","decimalSeparator","groupSeparator","groupSize","secondaryGroupSize","fractionGroupSeparator","fractionGroupSize","ALPHABET","alphabet","isNum","test","round","search","substring","format","rm","c0","ne","maxOrMin","method","m","normalise","sd","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","p","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","_isBigNumber","maximum","lt","minimum","gt","random","dp","rand","Uint32Array","copy","toBaseOut","baseIn","baseOut","arrL","arr","reverse","sign","callerIsToString","concat","multiply","base","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","equals","isFinite","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","xLTy","plus","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","split","g1","g2","intPart","fractionPart","isNeg","intDigits","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","NumberUtils","val","Number","UINT8_MAX","UINT16_MAX","UINT32_MAX","UINT64_MAX","UINT128_MAX","bin","buf","_toUint8View","ascii","String","fromCharCode","subarray","string","TextDecoder","_ISO_8859_15_DECODER","uint8View","decode","num","_BASE64_LOOKUP","u8","end","tmp","output","_tripletToBase64","join","extraBytes","parts","len2","_base64encodeChunk","Buffer","from","btoa","_codePointTextDecoder","_base64fromByteArray","base64","atob","map","toBase64","fromBase64","BASE32_ALPHABET","KRYPTON","symbol","base32","charmap","toUpperCase","forEach","char","hex","code","HEX_ALPHABET","trim","StringUtils","isHexBytes","match","lpad","TextEncoder","_UTF8_ENCODER","encode","_utf8TextEncoder","_strToUint8Array","o","EMPTY","fromHex","viewA","viewB","arrayLike","ArrayBuffer","BASE58_ALPHABET","strOutput","base58","bOutput","prefix","suffix","checksum","computeSha256","toBase58","hasSuffix","fromBase58","BASE64_ALPHABET","RFC4648","RFC4648_HEX","bufferOrArrayOrLength","_view","DataView","_readPos","_writePos","ArrayUtils","readPos","value","writePos","array","getUint8","setUint8","getUint16","setUint16","getUint32","setUint32","isUint64","op96","op64","op32","part1","part2","part3","part4","isUint128","readUint8","readUint16","readUint32","readUint64","writeUint8","writeUint16","writeUint64","getFloat64","setFloat64","bytes","read","toAscii","isMultibyte","fromAscii","view","byteOffset","padding","isUint8","sources","reduce","acc","offset","MinerWorker","blockHeader","compact","minNonce","maxNonce","MinerWorkerImpl","_malloc","nonce","_krypton_argon2_target","_free","MinerWorkerPool","_miningEnabled","_activeNonces","_block","_noncesPerRun","_observable","Observable","_shareCompact","Policy","BLOCK_TARGET_MAX","_runsPerCycle","Infinity","_cycleWait","_superUpdateToSize","cpuSupport","multiMine","fail","node_argon2_target_async","async","computeArgon2d","noncesPerRun","nonces","runsPerCycle","cycleWait","callback","on","off","shareCompact","nBits","_startMiner","nonceRange","_singleMiner","fire","newMin","newRange","RTCPeerConnection","webkitRTCPeerConnection","createDataChannel","location","protocol","navigator","onLine","platform","userAgentString","hardwareConcurrency","_importBrowserPromise","importWasmBrowser","importScriptBrowser","wasm","module","_adjustWasmPath","WebAssembly","xhr","XMLHttpRequest","open","responseType","wasmBinary","response","onerror","send","integrity","asm","_adjustScriptPath","moduleSettings","reject","runtimeInitialized","onRuntimeInitialized","importScripts","_loadBrowserScript","require","crossOrigin","__dirname","uintarr","begin","clamp","list","indices","reverseRange","found","Assert","condition","MerkleTree","values","fnHash","_hash","_computeRoot","light","mid","left","right","leftHash","rightHash","MerklePath","nodes","some","it","MerklePathNode","_nodes","leafValue","leafHash","path","_compute","containsLeaf","inner","leftLeaf","rightLeaf","root","node","serializedSize","count","leftBitsSize","leftBits","algorithm","_compress","sum","every","_left","coins","SATOSHIS_PER_COIN","satoshis","blockHeight","halving","HALVING_INTERVAL","HALVING_TARGET_MAX","INITIAL_BLOCK_REWARD","BLOCK_TIME_MILESTONE","INITIAL_BLOCK_TIME","BLOCK_TIME_MULTIPLE","initial","secondBlockTime","target","height","beginBlock","endBlock","blockMilestoneMax","range","beginRangeIndex","beginBlocksTime","endRangeIndex","endBlocksTime","middleBlocksTime","changing","TX_FEE_CHANGING_INTERVAL","TX_FEE_CHANGING_TOTAL_NUMBER","INITIAL_TX_FEE","FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE","INITIAL_BLOCK_SIZE","BASE_BLOCK_SIZE","BLOCK_SIZE_FACTOR","BLOCK_SIZE_CHANGING_INTERVAL","SECOND_FORKING_FOR_BLOCK_DIFFICULTY","DIFFICULTY_BLOCK_WINDOW","time","blockTime","DIFFICULTY_MAX_ADJUSTMENT_FACTOR","NEW_DIFFICULTY_MAX_ADJUSTMENT_FACTOR","NEW_DIFFICULTY_MIN_ADJUSTMENT_FACTOR","SECOND_DIFFICULTY_MAX_ADJUSTMENT_FACTOR","SECOND_DIFFICULTY_MIN_ADJUSTMENT_FACTOR","TRANSACTION_VALIDITY_WINDOW","INITIAL_SUPPLY","M","K","DELTA","NUM_BLOCKS_VERIFICATION","NUM_SNAPSHOTS_MAX","Serializable","toHex","toBase58Check","arg","BLAKE2B","_obj","_algorithm","blake2b","computeBlake2b","argon2d","SHA256","computeRipemd160","RIPEMD160","ripemd160","computeKeccak256","KECCAK256","sha256","fromAny","fromString","node_blake2","_krypton_blake2","node_sha256","_krypton_sha256","node_sha512","_krypton_sha512","node_ripemd160","_ripemd160","node_keccak256","_keccak256","hashAlgorithm","NULL","PublicKey","privateKey","_publicKeyDerive","_compressPublicKey","publicKeys","sort","_delinearizeAndAggregatePublicKeys","keccak256","Address","fromHash","PeerId","publicKeysObj","publicKeysHash","_publicKeysHash","raw","_publicKeysDelinearizeAndAggregate","publicKey","randomize","node_secp256k1_ctx_init","COMPRESSED_SIZE","node_secp256k1_pubkey_compress","node_secp256k1_ctx_release","rdm","HEAP8","_secp256k1_ctx_init","pubKeyBufferOut","_secp256k1_pubkey_compress","compressed","_secp256k1_ctx_release","PrivateKey","node_secp256k1_pubkey_create","pubKeyBuffer","privKeyBuffer","_secp256k1_pubkey_create","fill","concatenatedPublicKeys","node_secp256k1_hash_pubkeys","wasmInPublicKeys","_secp256k1_hash_pubkeys","hashedPublicKey","node_secp256k1_delinearize_pubkey","wasmInPublicKey","wasmInPublicKeysHash","_secp256k1_delinearize_pubkey","delinearizedPublicKey","node_secp256k1_aggregate_delinearized_publkeys","_secp256k1_aggregate_delinearized_publkeys","aggregatePublicKey","Signature","_signatureCreate","compress","commitment","signatures","_combinePartialSignatures","_signatureVerify","combinedCommitment","partialSignatures","_aggregatePartialSignatures","sigA","sigB","PartialSignature","HALF_SIZE","sA","sB","_scalarsAdd","node_secp256k1_add_scalars","wasmOutSum","wasmInA","wasmInB","_secp256k1_add_scalars","node_secp256k1_schnorr_sign","wasmOutSignature","signatureBuffer","wasmInMessage","wasmInPubKey","wasmInPrivKey","_secp256k1_schnorr_sign","signature","node_secp256k1_schnorr_verify","wasmInSignature","_secp256k1_schnorr_verify","SERIALIZED_SIZE","addr","toUserFriendlyAddress","fromUserFriendlyAddress","isBech32Address","Bech32","fromBech32","toBech32","withSpaces","HEX_SIZE","CONTRACT_CREATION","chk","top","GENERATOR","hrp","polymod","hrpExpand","ENCODING","combined","createChecksum","CHARSET","bechString","hasLower","hasUpper","pos","lastIndexOf","verifyChecksum","fromWidth","toWidth","pad","bits","maxv","address","useHRP","HRP","addrBz","convertBits","bech32Encode","bech32Decode","Account","balance","bigBalance","_type","_balance","TYPE_MAP","has","writeUint128","fromPlain","plain","Type","transaction","transactionsCache","revert","validityStartHeight","ValidityError","withBalance","fee","newBalance","BalanceError","containsTransaction","DoubleTransactionError","INITIAL","isInitial","proof","BASIC","VESTING","HTLC","ProofError","PrunedAccount","account","_address","_account","hashCode","toPlain","BasicAccount","readUint128","SignatureProof","verifyTransaction","hasFlag","Transaction","Flag","recipientType","withIncomingTransaction","create","dataToPlain","signatureProof","signer","toAddress","pathLength","merklePath","proofToPlain","Contract","recipient","getContractCreationAddress","HashedTimeLockedContract","sender","hashRoot","hashCount","timeout","totalAmount","bigTotalAmount","isUint32","_sender","_recipient","_hashRoot","_hashCount","_timeout","_totalAmount","ProofType","REGULAR_TRANSFER","hashDepth","preImage","compute","verify","serializeContent","EARLY_RESOLVE","TIMEOUT_RESOLVE","verifyIncomingTransaction","minCap","isSignedBy","withOutgoingTransaction","creatorSignatureProof","creator","creatorSignature","creatorPublicKey","creatorPathLength","proofType","VestingContract","owner","vestingStart","vestingStepBlocks","vestingStepAmount","vestingTotalAmount","bigVestingStepAmount","bigVestingTotalAmount","_owner","_vestingStart","_vestingStepBlocks","_vestingStepAmount","_vestingTotalAmount","getMinCap","BlockHeader","prevHash","accountsHash","timestamp","version","CURRENT_VERSION","isUint16","isHash","BlockUtils","isValidCompact","_version","_prevHash","_interlinkHash","_bodyHash","_accountsHash","_nBits","_height","_timestamp","_nonce","SUPPORTED_VERSIONS","includes","isProofOfWork","prevHeader","_pow","hard","compactToTarget","difficulty","compactToDifficulty","Version","V1","BlockInterlink","repeatBitsSize","repeatBits","lastHash","_hashes","_repeatBits","_compressed","computeRoot","BlockBody","extraData","minerAddr","prunedAccounts","_minerAddr","_extraData","_transactions","_prunedAccounts","extraDataLength","numTransactions","numPrunedAccounts","tx","previousTx","compareBlockOrder","previousAcc","isToBePruned","getMerkleLeafs","addresses","transactionCount","log2","getTargetHeight","targetToCompact","difficultyToTarget","targetToDifficulty","hashToTarget","getTargetDepth","isValidTarget","headBlock","tailBlock","deltaTotalDifficulty","blockWindow","difficultyBlockWindow","that","actualTime","adjustment","averageDifficulty","nextTarget","_header","_interlink","_body","isLight","now","blockVerify","TIMESTAMP_DRIFT_MAX","verifyProofOfWork","blockSize","_verifyInterlink","isFull","_verifyBody","predecessor","isImmediateSuccessorOf","getNextInterlink","prevPow","targetHeight","blockFound","depth","HashSet","addAll","removeAll","depthDiff","commonBlock","thisInterlink","prevInterlink","isInterlinkSuccessorOf","nextVersion","thisPowDepth","getHashDepth","nextTargetDepth","numOccurrences","h","pa","senderType","flags","bigValue","_format","_senderType","_recipientType","_value","_fee","txFee","_networkId","_validityStartHeight","_flags","_data","_proof","FORMAT_MAP","serializedContentSize","verifyOutgoingTransaction","recCompare","senderCompare","transactionHash","Format","feePerByte","network","networkIdToNetworkName","flag","EXTENDED","NONE","ALL","signerKey","_publicKey","_merklePath","_signature","SINGLE_SIG_SIZE","merkleRoot","BasicTransaction","senderPubKey","singleSig","_signatureProof","networkIdFromAny","ExtendedTransaction","dataSize","proofSize"],"mappings":"AAAA,MAAAA,MACAC,mBACA,MAAA,oBAAAC,QAAAA,QACA,oBAAAC,KAAAA,KACAC,OAGAC,gBAAAC,GACA,oBAAAJ,UAAAA,QAAAI,EAAAC,MAAAD,IAGAN,MAAAQ,SAAAR,OCXA,MAAAS,UACAJ,cACAK,KAAAC,cAAAC,IAAAC,KACAH,KAAAI,YAAA,GACA,IACA,GAAAV,OAAAW,aACA,IACA,IAAAC,EAAAZ,OAAAW,aAAAE,QAAA,kBACAD,GAAA,iBAAAA,IAAAA,EAAAE,KAAAC,MAAAH,IACAA,GAAA,iBAAAA,IAAAN,KAAAI,YAAAE,GACA,MAAAI,GACAC,QAAAC,KAAA,yDAGA,MAAAF,KAKAf,WAAAkB,EAAAC,GACA,OAAAD,GAAAb,KAAAI,YAAAS,GACAb,KAAAI,YAAAS,IAAAC,EAEAd,KAAAI,YAAA,KACAJ,KAAAI,YAAA,MAAAU,EAEAd,KAAAC,eAAAa,EAGAnB,YAAAkB,EAAAC,GACAD,GAAAA,EAAAhB,OAAAgB,EAAAA,EAAAhB,MACAG,KAAAI,YAAAS,GAAAC,EACApB,OAAAW,cACAX,OAAAW,aAAAU,QAAA,iBAAAP,KAAAQ,UAAAhB,KAAAI,cAIAT,IAAAmB,EAAAD,EAAAI,GACAJ,GAAAA,EAAAhB,OAAAgB,EAAAA,EAAAhB,MACAG,KAAAkB,WAAAL,EAAAC,KACAD,GAAAI,EAAAE,QAAAN,EAAA,KACAI,EAAAE,YAAAjB,IAAAkB,MAAAC,YAAAP,OAAA,IAAAQ,MAAAC,eAAAC,OAAA,EAAA,OACAb,QAAAc,OAAAX,GAAAZ,IAAAwB,MACAf,QAAAc,MAAAE,MAAAhB,QAAAM,GACAN,QAAAC,MAAAE,GAAAZ,IAAA0B,QACAjB,QAAAC,KAAAe,MAAAhB,QAAAM,GACAN,QAAAkB,MAAAf,GAAAZ,IAAAC,KACAQ,QAAAkB,KAAAF,MAAAhB,QAAAM,GACAN,QAAAmB,OAAAhB,GAAAZ,IAAA6B,MACApB,QAAAmB,MAAAH,MAAAhB,QAAAM,GACAN,QAAAqB,OAAAlB,GAAAZ,IAAA+B,MACAtB,QAAAqB,MAAAL,MAAAhB,QAAAM,GAEAN,QAAAuB,IAAAP,MAAAhB,QAAAM,KAIA3B,MAAAQ,SAAAC,WCzDA,MAAAG,IAIAiC,sBAIA,OAHAjC,IAAAkC,YACAlC,IAAAkC,UAAA,IAAAlC,IAAA,IAAAH,YAEAG,IAAAkC,UAMAzC,YAAA0C,GAEArC,KAAAsC,QAAAD,EAOA1C,YAAAkB,EAAAC,GACAd,KAAAsC,QAAAC,YAAA1B,EAAAX,IAAAkB,MAAAoB,IAAA1B,IAIAA,YACA,OAAAd,KAAAsC,QAAArC,cAIAa,UAAA2B,GACAzC,KAAAsC,QAAArC,cAAAC,IAAAkB,MAAAoB,IAAAC,GAQA9C,IAAAmB,EAAAD,EAAAI,GACA,GAAAjB,KAAAsC,QAAApB,WAAAL,EAAAC,GAAA,CACA,IAAA,IAAA4B,EAAA,EAAAA,EAAAzB,EAAA0B,SAAAD,EACA,mBAAAzB,EAAAyB,KACAzB,EAAAyB,GAAAzB,EAAAyB,MAEA,iBAAAzB,EAAAyB,KACA,mBAAAzB,EAAAyB,GAAAE,SACA3B,EAAAyB,GAAAzB,EAAAyB,GAAAE,WACA3B,EAAAyB,GAAAG,aAAA5B,EAAAyB,GAAAG,YAAAhD,KACAoB,EAAAyB,eAAAzB,EAAAyB,GAAAG,YAAAhD,QAEAoB,EAAAyB,GAAA,YAIA1C,KAAAsC,QAAAQ,IAAAhC,EAAAD,EAAAI,IASAtB,SAAAkB,EAAAkC,KAAA9B,GACA+B,UAAAL,QAAA,GACA9B,EAAAmC,UAAA,GACA/B,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,KAEAnC,OAAAwC,EACApC,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,IAEA9C,IAAAiC,SAAAW,IAAA5C,IAAA6B,MAAAlB,EAAAI,GAQAtB,SAAAkB,EAAAkC,KAAA9B,GACA+B,UAAAL,QAAA,GACA9B,EAAAmC,UAAA,GACA/B,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,KAEAnC,OAAAwC,EACApC,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,IAEA9C,IAAAiC,SAAAW,IAAA5C,IAAAwB,MAAAb,EAAAI,GAQAtB,SAAAkB,EAAAkC,KAAA9B,GACA+B,UAAAL,QAAA,GACA9B,EAAAmC,UAAA,GACA/B,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,KAEAnC,OAAAwC,EACApC,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,IAEA9C,IAAAiC,SAAAW,IAAA5C,IAAAC,KAAAU,EAAAI,GAQAtB,SAAAkB,EAAAkC,KAAA9B,GACA+B,UAAAL,QAAA,GACA9B,EAAAmC,UAAA,GACA/B,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,KAEAnC,OAAAwC,EACApC,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,IAEA9C,IAAAiC,SAAAW,IAAA5C,IAAAoD,QAAAzC,EAAAI,GAQAtB,SAAAkB,EAAAkC,KAAA9B,GACA+B,UAAAL,QAAA,GACA9B,EAAAmC,UAAA,GACA/B,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,KAEAnC,OAAAwC,EACApC,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,IAEA9C,IAAAiC,SAAAW,IAAA5C,IAAA0B,QAAAf,EAAAI,GAQAtB,SAAAkB,EAAAkC,KAAA9B,GACA+B,UAAAL,QAAA,GACA9B,EAAAmC,UAAA,GACA/B,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,KAEAnC,OAAAwC,EACApC,EAAAgC,MAAAC,UAAAC,MAAAC,KAAAJ,UAAA,IAEA9C,IAAAiC,SAAAW,IAAA5C,IAAA+B,MAAApB,EAAAI,IAOAf,IAAAkB,MAAA,CACAa,MAAA,EACAqB,QAAA,EACAvB,MAAA,EACA5B,KAAA,EACAyB,QAAA,EACAF,MAAA,EACA6B,OAAA,EAMAlC,YAAA,SAAAP,GACA,OAAAA,GACA,KAAAZ,IAAAkB,MAAAa,MACA,MAAA,IACA,KAAA/B,IAAAkB,MAAAkC,QACA,MAAA,IACA,KAAApD,IAAAkB,MAAAW,MACA,MAAA,IACA,KAAA7B,IAAAkB,MAAAjB,KACA,MAAA,IACA,KAAAD,IAAAkB,MAAAQ,QACA,MAAA,IACA,KAAA1B,IAAAkB,MAAAM,MACA,MAAA,IACA,KAAAxB,IAAAkB,MAAAmC,OACA,MAAA,IACA,QACA,MAAA,MAIAX,SAAA,SAAA9B,GACA,OAAAA,GACA,KAAAZ,IAAAkB,MAAAa,MACA,MAAA,QACA,KAAA/B,IAAAkB,MAAAkC,QACA,MAAA,UACA,KAAApD,IAAAkB,MAAAW,MACA,MAAA,QACA,KAAA7B,IAAAkB,MAAAjB,KACA,MAAA,OACA,KAAAD,IAAAkB,MAAAQ,QACA,MAAA,OACA,KAAA1B,IAAAkB,MAAAM,MACA,MAAA,QACA,KAAAxB,IAAAkB,MAAAmC,OACA,MAAA,SACA,QACA,MAAA,YAQAf,IAAA,SAAAgB,GACA,GAAA,iBAAAA,EAAA,OAAAA,EACA,IAAAC,MAAAC,SAAAF,IAAA,OAAAE,SAAAF,GACA,OAAAA,EAAAG,eACA,IAAA,IACA,IAAA,QACA,OAAAzD,IAAAkB,MAAAa,MACA,IAAA,IACA,IAAA,UACA,OAAA/B,IAAAkB,MAAAkC,QACA,IAAA,IACA,IAAA,QACA,OAAApD,IAAAkB,MAAAW,MACA,IAAA,IACA,IAAA,OACA,OAAA7B,IAAAkB,MAAAjB,KACA,IAAA,IACA,IAAA,OACA,IAAA,UACA,OAAAD,IAAAkB,MAAAQ,QACA,IAAA,IACA,IAAA,QACA,IAAA,YACA,OAAA1B,IAAAkB,MAAAM,MACA,IAAA,IACA,IAAA,SACA,IAAA,YACA,OAAAxB,IAAAkB,MAAAmC,OAEA,OAAA,IAGArD,IAAA+B,MAAA/B,IAAAkB,MAAAa,MACA/B,IAAAoD,QAAApD,IAAAkB,MAAAkC,QACApD,IAAA6B,MAAA7B,IAAAkB,MAAAW,MACA7B,IAAAC,KAAAD,IAAAkB,MAAAjB,KACAD,IAAA0B,QAAA1B,IAAAkB,MAAAQ,QACA1B,IAAAwB,MAAAxB,IAAAkB,MAAAM,MACAxB,IAAAqD,OAAArD,IAAAkB,MAAAmC,OACArD,IAAAkC,UAAA,KAEAlC,IAAA0D,EAAA/C,IAAA,CAAAA,GAAAX,IAAA0D,EAAAC,KAAA,KAAAhD,IACAX,IAAAQ,EAAAG,IAAA,CAAAA,GAAAX,IAAAQ,EAAAmD,KAAA,KAAAhD,IACAX,IAAAwC,EAAA7B,IAAA,CAAAA,GAAAX,IAAAwC,EAAAmB,KAAA,KAAAhD,IACAX,IAAAsD,EAAA3C,IAAA,CAAAA,GAAAX,IAAAsD,EAAAK,KAAA,KAAAhD,IACAX,IAAA4D,EAAAjD,IAAA,CAAAA,GAAAX,IAAA4D,EAAAD,KAAA,KAAAhD,IACAX,IAAA6D,EAAAlD,IAAA,CAAAA,GAAAX,IAAA6D,EAAAF,KAAA,KAAAhD,IAEAvB,MAAAQ,SAAAI,KC1QA,MAAA8D,QACArE,yBAAAsE,EAAApE,EAAAqE,GACA,OAAA,IAAAF,QAAAG,MAAAF,GAAA,CAAAC,EAAArE,GAGAF,iCAAAsE,EAAApE,EAAAuE,GACA,OAAAJ,QAAAK,mBAIAD,IACAA,KAAAE,QAAAC,kBAEAP,QAAAQ,YAAAP,EAAApE,EAAA,IAAA4E,OAAAC,IAAAC,gBAAA,IAAAC,KAAA,uBAAAN,QAAAC,2BAAAH,EAAAS,QAAA,KAAA,sBANAb,QAAAc,sBAAAb,EAAApE,MAAAkF,KAAAlF,GACAmE,QAAAc,sBAAAb,EAAApE,OASAF,qCAAAsE,EAAApE,EAAAmF,EAAAZ,GACA,OAAA,IAAAJ,QAAAiB,KAAAhB,GAAA,CAAApE,GAAAmE,QAAAkB,oBAAAjB,EAAApE,EAAAuE,GAAAvE,EAAAmF,GAAAG,QAGAxF,+BAAAmD,GACA,IACA,GAAA,SAAAA,EAAAsC,KAAAC,QACA,GAAArB,QAAAc,sBAAAhC,EAAAsC,KAAAnE,KAAA,IAAA,CACA,MAAAqE,QAAAtB,QAAAc,sBAAAhC,EAAAsC,KAAAnE,KAAA,IAAA8D,KAAAjC,EAAAsC,KAAAnE,KAAA,IACAxB,KAAA8F,YAAA,CAAAC,OAAA,KAAAC,OAAAH,EAAAI,GAAA5C,EAAAsC,KAAAM,UAEAjG,KAAA8F,YAAA,CAAAC,OAAA,QAAAC,OAAA,kBAAAC,GAAA5C,EAAAsC,KAAAM,UAGAjG,KAAA8F,YAAA,CAAAC,OAAA,QAAAC,OAAA,8BAAAC,GAAA5C,EAAAsC,KAAAM,KAEA,MAAAhF,GACAjB,KAAA8F,YAAA,CAAAC,OAAA,QAAAC,OAAA/E,EAAAgF,GAAA5C,EAAAsC,KAAAM,MAIArB,+BACA,MAAA,oBAAAI,OAGAkB,6BACA,OAAA3B,QAAAK,kBAGAuB,8BACA,MAAA,oBAAAC,mBAAApG,gBAAAoG,kBAGAC,qBACA,MAAA,oBAAAC,OAAAA,OAAA,oBAAArG,OAAAA,OAAA,oBAAAD,KAAAA,KAAA,KAGAE,2BAAAqG,EAAAC,GACAjC,QAAA4B,mBAEAnG,KAAAyG,UAAAlC,QAAAmC,mBAEAnC,QAAAc,sBAAAd,QAAAc,uBAAA,GACAd,QAAAc,sBAAAkB,EAAAnG,MAAAoG,EAGAtG,0BAAAyG,EAAAC,GAEA,MAAAC,EAAAC,SAAAC,qBAAA,QAAA,GACAC,EAAAF,SAAAG,cAAA,UACAD,EAAAE,KAAA,kBACAF,EAAAG,IAAAR,EAKA,MAAAS,EAAA,IAAAC,WAAAT,EAAA,KACAI,EAAAM,mBAAAF,EACAJ,EAAAO,OAAAH,EAGAP,EAAAW,YAAAR,GAGA9G,aAAAsE,GACA,MAAAiD,EAAA,cAAAjD,EAKAtE,YAAAuE,EAAArE,GAQA,OAPAsH,QACAnH,KAAAoH,MAAAvH,EACAG,KAAAqH,WAAA,EACArH,KAAAsH,QAAApD,EACAlE,KAAAsH,QAAApB,UAAAlG,KAAAuH,SAAA1D,KAAA7D,MAEAA,KAAAwH,SAAA,IAAAC,IACAzH,KAAA0H,QAAA,OAAA,CAAAzD,EAAApE,KAAAA,IAAA8H,KAAA,IAAA3H,MAGAL,SAAAmD,GACA,MAAA8E,EAAA5H,KAAAwH,SAAAhF,IAAAM,EAAAsC,KAAAM,IACAkC,GAGA5H,KAAAwH,SAAAK,OAAA/E,EAAAsC,KAAAM,IACA,OAAA5C,EAAAsC,KAAAI,OACAoC,EAAAvB,QAAAvD,EAAAsC,KAAAK,QACA,UAAA3C,EAAAsC,KAAAI,QACAoC,EAAAnG,MAAAqB,EAAAsC,KAAAK,SANAvF,IAAA4D,EAAAgE,YAAA,gBAAAhF,GAiBAnD,QAAA0F,EAAApE,EAAA,IACA,OAAA,IAAA8G,QAAA,CAAA1B,EAAA5E,KACA,MAAAuG,EAAA,CAAA3C,QAAAA,EAAApE,KAAAA,EAAAyE,GAAA1F,KAAAqH,cACArH,KAAAwH,SAAAS,IAAAD,EAAAtC,GAAA,CAAAW,QAAAA,EAAA5E,MAAAA,IACAzB,KAAAsH,QAAA/B,YAAAyC,KAIArI,UACA,OAAAK,KAAA0H,QAAA,aAGA,IAAA,MAAAQ,KAAAC,OAAAC,oBAAAnE,EAAAf,WACA,mBAAAe,EAAAf,UAAAgF,IAAA,gBAAAA,IACAhB,EAAAhE,UAAAgF,GAAA,YAAAjH,GACA,OAAAjB,KAAA0H,QAAAQ,EAAAjH,KAIA,OAAAiG,EAQAvH,YAAAsE,GACA,MAAAoE,EAAA,cAAApE,EACAtE,cACAwH,QAGAxH,QAAAmD,EAAA0C,EAAAC,GACAhG,KAAA8F,YAAA,CAAAC,OAAAA,EAAAC,OAAAA,EAAAC,GAAA5C,EAAAsC,KAAAM,KAGA/F,WAAAmD,GACA,IACA,MAAAwC,EAAAtF,KAAA0H,QAAA5E,EAAAsC,KAAAC,QAAAvC,EAAAsC,KAAAnE,MACAqE,aAAAyC,QACAzC,EAAAqC,KAAAW,IAAAtI,KAAAuI,QAAAzF,EAAA,KAAAwF,KAEAtI,KAAAuI,QAAAzF,EAAA,KAAAwC,GAEA,MAAA5E,GACAV,KAAAuI,QAAAzF,EAAA,QAAApC,EAAAqC,SAAArC,IAIAf,KAAAE,GACAG,KAAAoH,MAAAvH,EACAmE,QAAA4B,mBACAnG,KAAAI,KAAAA,EACAJ,KAAAyG,UAAA,CAAApD,GAAA9C,KAAAwI,WAAA1F,KAIAnD,QAAA0F,EAAApE,GACA,OAAAjB,KAAAqF,GAAA1D,MAAA3B,KAAAiB,GAGAtB,UACAqE,QAAA4B,kBACAnG,KAAAgJ,UAIA,IAAA,MAAAP,KAAAC,OAAAC,oBAAAnE,EAAAf,WACA,mBAAAe,EAAAf,UAAAgF,IAAA,gBAAAA,IACAG,EAAAnF,UAAAgF,GAAA,WACA,yCAAAA,MAIA,OAAAG,EAGA1I,YAAAsE,GACA,MAAAyE,EAAA,cAAAzE,EAOAtE,YAAAgJ,EAAA9I,EAAA,OAAAmF,EAAA,GACAmC,QAEAnH,KAAA4I,kBAAAD,EAEA3I,KAAAoH,MAAAvH,EAEAG,KAAA6I,UAAA7D,EAEAhF,KAAA8I,SAAA,GAEA9I,KAAA+I,aAAA,GAEA/I,KAAAgJ,cAAA,GAGArJ,cAGA,aAFAK,KAAAiJ,gBAEAjJ,KAGAkJ,eACA,OAAAlJ,KAAA6I,UAGAK,aAAAC,GACAnJ,KAAA6I,UAAAM,EACAnJ,KAAAiJ,gBAAAG,MAAAlJ,IAAA4D,EAAAjD,IAAAmD,UAGArE,UAEA,OADAK,KAAA6I,UAAA,EACA7I,KAAAiJ,gBAQAtJ,QAAAE,EAAAoB,GACA,OAAA+C,QAAAK,kBACA,IAAA0D,QAAA,CAAA1B,EAAA5E,KACAzB,KAAAgJ,cAAAK,KAAA,CAAAxJ,KAAAA,EAAAoB,KAAAA,EAAAoF,QAAAA,EAAA5E,MAAAA,IACA,MAAAyC,EAAAlE,KAAA+I,aAAAO,QACApF,GACAlE,KAAAuJ,MAAArF,GAAAkF,MAAAlJ,IAAA4D,EAAAjD,IAAAmD,YAIAhE,KAAA8I,SAAA,GAAAjJ,GAAA8B,MAAA3B,KAAA8I,SAAA,GAAA7H,GASAtB,YAAAuE,GACA,IAAAd,EAAApD,KAAAgJ,cAAAM,QACA,KAAAlG,GAAA,CACA,IAEAA,EAAAiD,cAAAnC,EAAAd,EAAAvD,MAAA8B,MAAAuC,EAAAd,EAAAnC,OACA,MAAAP,GACA0C,EAAA3B,MAAAf,GAEA,IAAA,IAAAV,KAAA8I,SAAAU,QAAAtF,GAEA,YADAA,EAAAuF,UAGArG,EAAApD,KAAAgJ,cAAAM,QAEAtJ,KAAA+I,aAAAM,KAAAnF,GAGAvE,sBACA,oBAAA8E,QAAAzE,KAAA6I,UAAA,IACA3I,IAAA0D,EAAAI,QAAA,0DACAhE,KAAA6I,UAAA,GAGA,MAAAa,EAAA,GACA,KAAA1J,KAAA8I,SAAAnG,OAAA+G,EAAA/G,OAAA3C,KAAA6I,WACAa,EAAAL,KAAArJ,KAAA4I,qBAAA5I,KAAAoH,SAAApH,KAAA8I,SAAAnG,OAAA+G,EAAA/G,WAEA,MAAAgH,QAAA5B,QAAA6B,IAAAF,GACA,IAAA,MAAAxF,KAAAyF,EACA3J,KAAA8I,SAAAO,KAAAnF,GACAlE,KAAAuJ,MAAArF,GAAAkF,MAAAlJ,IAAA4D,EAAAjD,IAAAmD,UAGA,KAAAhE,KAAA8I,SAAAnG,OAAA3C,KAAA6I,WAAA,CACA,MAAA3E,EAAAlE,KAAA+I,aAAAO,SAAAtJ,KAAA8I,SAAAe,MACAC,EAAA9J,KAAA8I,SAAAU,QAAAtF,GACA4F,GAAA,IAEA9J,KAAA8I,SAAAiB,OAAAD,EAAA,GACA5F,EAAAuF,WAGA,OAAAzJ,OAGA,IAAA,MAAAkI,KAAAC,OAAAC,oBAAAnE,EAAAf,WACA,mBAAAe,EAAAf,UAAAgF,IAAA,gBAAAA,IACAQ,EAAAxF,UAAAgF,GAAA,YAAAjH,GACA,OAAAjB,KAAA0H,QAAAQ,EAAAjH,KAIA,OAAAyH,GAIA1E,QAAAgG,uBAAA,GACAhG,QAAAc,sBAAA,GACAxF,MAAAQ,SAAAkE,SCtUA,MAAAiG,YAMAtK,yBAAAuK,EAAA9E,GACA8E,EAAAvH,OAAAsH,YAAAE,oBACAD,EAAA,IAAAE,aAAAC,KAAAC,cAAAJ,KAGA,MAAAK,EAAA,IAAAH,aAAAH,YAAAE,mBACAK,EAAA,IAAAJ,aAAAH,YAAAE,mBACA,IAAA,IAAAzH,EAAA,EAAAA,EAAAuH,YAAAE,oBAAAzH,EAAA,CACA,MAAA+H,EAAAP,EAAAxH,IAAA,EACA6H,EAAA7H,GAAA,GAAA+H,EACAD,EAAA9H,GAAA,GAAA+H,EAGA,MAAAC,EAAAL,KAAAC,cAAAK,YAAAC,kBAAAL,EAAAnF,IACA,OAAAiF,KAAAC,cAAAK,YAAAC,kBAAAJ,EAAAE,IAUA/K,2BAAAkL,EAAAC,EAAAC,EAAAC,GAEA,MAAAC,EAAAZ,KAAAa,KAAA1I,IAAA6H,KAAAc,UAAAC,QAEA,GAAAJ,GAAAK,KAAAC,IAAA,EAAA,IAAA,GAAAL,EACA,MAAA,IAAAM,MAAA,wBAGA,MAAA9I,EAAA4I,KAAAG,KAAAR,EAAAC,GACAQ,EAAAT,GAAAvI,EAAA,GAAAwI,EAEAS,EAAA,IAAAtB,aAAAY,GACA,IAAA,IAAAtI,EAAA,EAAAA,GAAAD,EAAAC,IAAA,CACA,IAAAiJ,EAAA,IAAAvB,aAAAU,EAAAnI,OAAA,GACAgJ,EAAAC,MAAAd,GACAa,EAAAE,YAAAnJ,GAGA,MAAAqB,EADA4H,EAAA1B,YAAA6B,kBAAAjB,EAAAc,GAEA,IAAA,IAAAI,EAAA,EAAAA,EAAAhB,EAAAgB,IAAA,CACAJ,EAAA1B,YAAA6B,kBAAAjB,EAAAc,GACA,IAAA,IAAAK,EAAA,EAAAA,EAAAjI,EAAApB,OAAAqJ,IACAjI,EAAAiI,IAAAL,EAAAK,GAIAtJ,EAAAD,EACAiJ,EAAAE,MAAA7H,GAEA2H,EAAAE,MAAA7H,EAAAZ,MAAA,EAAAsI,IAGA,OAAAC,EAWA/L,0BAAAoD,EAAAmH,EAAAY,EAAAC,GACA,MAAA7G,QAAA+H,aAAAC,mBACAR,QAAAxH,EAAAiI,UAAAjC,EAAAY,EAAAC,EAAAhI,EAAAqJ,YACA,OAAAzB,YAAA0B,IAAAtJ,EAAA2I,GAUA/L,oBAAAoD,EAAAmH,EAAAY,EAAAC,GACA,MAAA7G,QAAA+H,aAAAC,mBACAR,QAAAxH,EAAAoI,IAAApC,EAAAY,EAAAC,EAAAhI,EAAAqJ,YACA,OAAAzB,YAAA0B,IAAAtJ,EAAA2I,IAIAzB,YAAAE,kBAAA,IAEA7K,MAAAQ,SAAAmK,aC5FA,MAAAgC,aACAM,iBAAA,OAAAC,UAAArK,SAKAxC,gCAIA,OAHAsM,aAAAQ,eACAR,aAAAQ,mBAAAzI,QAAA0I,wBAAAT,aAAA,SAAA,IAEAA,aAAAQ,aAMA9M,qBAAAgN,IAMAhN,0BAAAiN,IAUAjN,gBAAAuK,EAAAY,EAAAC,EAAA8B,IASAlN,UAAAuK,EAAAY,EAAAC,EAAA8B,IAUAlN,kBAAAmN,EAAAC,EAAAC,EAAAC,EAAAC,KAGAjB,aAAAQ,aAAA,KAEAnN,MAAAQ,SAAAmM,cC3DA,MAAAkB,yBAAAnJ,QAAAqE,KAAA4D,eACAtM,cACAwH,QAEAnH,KAAAoN,WAAAjG,MAAApC,KAGApF,WAAAE,SACAG,KAAAoN,WAAAhK,KAAApD,KAAAH,GACAwN,cAAAC,mBAAAC,WAAAC,kBACAvB,aAAAQ,aAAAzM,KAOAL,eAAAgN,GACA,GAAAU,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAtD,KAAAuD,QAAAvD,KAAAc,UAAA0C,UACAvI,EAAAwI,WAAAC,YAAAL,EAAA,IAAAC,WAAAhB,GAAA,KACA,GAAA,IAAArH,EACA,MAAAA,EAEA,OAAAoI,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAC,EAAA9D,KAAAuD,QAAAvD,KAAAc,UAAA0C,SACAO,EAAAH,OAAAI,WAAAF,GACAG,EAAAL,OAAAI,WAAA1B,EAAAhK,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAA3B,EAAAhK,QAAAsF,IAAA0E,GACA,MAAArH,EAAA2I,OAAAQ,gBAAAL,EAAAE,EAAA3B,EAAAhK,OAAA,KACA,GAAA,IAAA2C,EACA,MAAAA,EAEA,MAAAoJ,EAAA,IAAAf,WAAAQ,GAEA,OADAO,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAD,IACAO,EACA,MAAAhO,GAEA,MADAR,IAAA4D,EAAAqJ,iBAAAzM,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KASArO,oBAAAiN,GACA,MAAAgC,EAAA,GACA,GAAAvB,cAAAI,WAAA,CACA,IAAA,MAAAd,KAAAC,EAAA,CACA,MAAAc,EAAA,IAAAC,WAAAtD,KAAAuD,QAAAvD,KAAAc,UAAA0C,UACAvI,EAAAwI,WAAAC,YAAAL,EAAA,IAAAC,WAAAhB,GAAA,KACA,GAAA,IAAArH,EACA,MAAAA,EAEAsJ,EAAAvF,KAAAqE,GAEA,OAAAkB,EACA,CACA,IAAAZ,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAC,EAAA9D,KAAAuD,QAAAvD,KAAAc,UAAA0C,SACAO,EAAAH,OAAAI,WAAAF,GACAU,EAAAZ,OAAAC,YACA,IAAA,MAAAvB,KAAAC,EAAA,CACAqB,OAAAU,aAAAE,GACA,MAAAP,EAAAL,OAAAI,WAAA1B,EAAAhK,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAA3B,EAAAhK,QAAAsF,IAAA0E,GACA,MAAArH,EAAA2I,OAAAQ,gBAAAL,EAAAE,EAAA3B,EAAAhK,OAAA,KACA,GAAA,IAAA2C,EACA,MAAAA,EAEA,MAAAoJ,EAAA,IAAAf,WAAAQ,GACAO,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAD,IACAS,EAAAvF,KAAAqF,GAEA,OAAAE,EACA,MAAAlO,GAEA,MADAR,IAAA4D,EAAAqJ,iBAAAzM,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KAaArO,UAAAuK,EAAAY,EAAAC,EAAA8B,EAAAxC,KAAAuD,QAAAvD,KAAAc,UAAA0C,UACA,GAAAR,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAd,GACAvH,EAAAwI,WAAAgB,gBAAApB,EAAA,IAAAC,WAAAzD,GAAA,IAAAyD,WAAA7C,GAAA,IAAAC,GACA,GAAA,IAAAzF,EACA,MAAAA,EAEA,OAAAoI,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAE,EAAAH,OAAAI,WAAAxB,GACAyB,EAAAL,OAAAI,WAAAnE,EAAAvH,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAApE,EAAAvH,QAAAsF,IAAAiC,GACA,MAAA6E,EAAAd,OAAAI,WAAAvD,EAAAnI,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAO,EAAAjE,EAAAnI,QAAAsF,IAAA6C,GACA,MAAAxF,EAAA2I,OAAAe,oBAAAZ,EAAAvB,EAAAyB,EAAApE,EAAAvH,OAAAoM,EAAAjE,EAAAnI,OAAA,IAAAoI,GACA,GAAA,IAAAzF,EACA,MAAAA,EAEA,MAAAoJ,EAAA,IAAAf,WAAAd,GAEA,OADA6B,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAvB,IACA6B,EACA,MAAAhO,GAEA,MADAR,IAAA4D,EAAAqJ,iBAAAzM,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KAYArO,IAAAuK,EAAAY,EAAAC,EAAA8B,EAAAxC,KAAAuD,QAAAvD,KAAAc,UAAA0C,UACA,GAAAR,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAd,GACAvH,EAAAwI,WAAAmB,SAAAvB,EAAA,IAAAC,WAAAzD,GAAA,IAAAyD,WAAA7C,GAAA,IAAAC,GACA,GAAA,IAAAzF,EACA,MAAAA,EAEA,OAAAoI,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAE,EAAAH,OAAAI,WAAAxB,GACAyB,EAAAL,OAAAI,WAAAnE,EAAAvH,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAApE,EAAAvH,QAAAsF,IAAAiC,GACA,MAAA6E,EAAAd,OAAAI,WAAAvD,EAAAnI,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAO,EAAAjE,EAAAnI,QAAAsF,IAAA6C,GACA,MAAAxF,EAAA2I,OAAAiB,aAAAd,EAAAvB,EAAAyB,EAAApE,EAAAvH,OAAAoM,EAAAjE,EAAAnI,OAAA,IAAAoI,GACA,GAAA,IAAAzF,EACA,MAAAA,EAEA,MAAAoJ,EAAA,IAAAf,WAAAd,GAEA,OADA6B,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAvB,IACA6B,EACA,MAAAhO,GAEA,MADAR,IAAA4D,EAAAqJ,iBAAAzM,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KAaArO,kBAAAwP,EAAApC,EAAAC,EAAAC,EAAAC,GAEAkC,cAAA,CACAC,aAAAhF,KAAAiF,YAAA,IAAAlF,aAAA6C,IACAsC,WAAArC,GAGA,MAAAJ,EAAA0C,MAAAF,YAAA,IAAAlF,aAAA+E,IACA,IAAA,IAAAzM,EAAA,EAAAA,EAAAqK,EAAApK,OAAAD,IACAoK,EAAA2C,KAAAC,aAAAhN,GAAAiN,OAAA5C,EAAArK,GAGA,MAAAkN,QAAA9C,EAAA+C,QAAA7C,GACA1B,QAAAwB,EAAAgD,OAAAxE,MACAyE,EAAAjD,EAAAkD,UAAAtB,OACAuB,EAAAnD,EAAA2C,KAAAf,OACA,MAAA,CAAAkB,MAAAA,EAAAtE,IAAAA,EAAA4E,YAAAH,cAAAA,EAAAG,YAAAD,SAAAA,EAAAC,cAIAlM,QAAAmM,oBAAAlE,aAAA,IAAAkB,kBC3MA,SAAAiD,GACA,aAkDA,IAAAC,EACAC,EAAA,6CAEAC,EAAAlF,KAAAG,KACAgF,EAAAnF,KAAAoF,MAEAC,EAAA,qBACAC,EAAAD,EAAA,yDAEAE,EAAA,KACAC,EAAA,GACAC,EAAA,iBAEAC,EAAA,CAAA,EAAA,GAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,KAAA,KAAA,KAAA,MACAC,EAAA,IAKAC,EAAA,IA0hFA,SAAAC,EAAAC,GACA,IAAAzO,EAAA,EAAAyO,EACA,OAAAA,EAAA,GAAAA,IAAAzO,EAAAA,EAAAA,EAAA,EAKA,SAAA0O,EAAAC,GAMA,IALA,IAAAC,EAAAC,EACA7O,EAAA,EACAqJ,EAAAsF,EAAA1O,OACA8I,EAAA4F,EAAA,GAAA,GAEA3O,EAAAqJ,GAAA,CAGA,IAFAuF,EAAAD,EAAA3O,KAAA,GACA6O,EAAAV,EAAAS,EAAA3O,OACA4O,IAAAD,EAAA,IAAAA,GACA7F,GAAA6F,EAIA,IAAAvF,EAAAN,EAAA9I,OAAA,KAAA8I,EAAA+F,aAAAzF,KACA,OAAAN,EAAAtI,MAAA,EAAA4I,EAAA,GAAA,GAKA,SAAA0F,EAAAC,EAAAC,GACA,IAAAN,EAAAO,EACAC,EAAAH,EAAApR,EACAwR,EAAAH,EAAArR,EACAoC,EAAAgP,EAAAJ,EACAvF,EAAA4F,EAAAL,EACAtF,EAAA0F,EAAAhR,EACA+B,EAAAkP,EAAAjR,EAGA,IAAAgC,IAAAqJ,EAAA,OAAA,KAMA,GAJAsF,EAAAQ,IAAAA,EAAA,GACAD,EAAAE,IAAAA,EAAA,GAGAT,GAAAO,EAAA,OAAAP,EAAAO,EAAA,GAAA7F,EAAArJ,EAGA,GAAAA,GAAAqJ,EAAA,OAAArJ,EAMA,GAJA2O,EAAA3O,EAAA,EACAkP,EAAA5F,GAAAvJ,GAGAoP,IAAAC,EAAA,OAAAF,EAAA,GAAAC,EAAAR,EAAA,GAAA,EAGA,IAAAO,EAAA,OAAA5F,EAAAvJ,EAAA4O,EAAA,GAAA,EAKA,IAHAtF,GAAAC,EAAA6F,EAAAlP,SAAAF,EAAAqP,EAAAnP,QAAAqJ,EAAAvJ,EAGAC,EAAA,EAAAA,EAAAqJ,EAAArJ,IAAA,GAAAmP,EAAAnP,IAAAoP,EAAApP,GAAA,OAAAmP,EAAAnP,GAAAoP,EAAApP,GAAA2O,EAAA,GAAA,EAGA,OAAArF,GAAAvJ,EAAA,EAAAuJ,EAAAvJ,EAAA4O,EAAA,GAAA,EAOA,SAAAU,EAAAZ,EAAAa,EAAAC,EAAApS,GACA,GAAAsR,EAAAa,GAAAb,EAAAc,GAAAd,KAAAA,EAAA,EAAAZ,EAAAY,GAAAX,EAAAW,IACA,MAAA5F,MACAmF,GAAA7Q,GAAA,aAAA,iBAAAsR,EACAA,EAAAa,GAAAb,EAAAc,EAAA,kBAAA,oBACA,6BAAAd,GAKA,SAAAe,EAAAlK,GACA,MAAA,kBAAAG,OAAAjF,UAAAN,SAAAQ,KAAA4E,GAKA,SAAAmK,EAAAhB,GACA,IAAAnF,EAAAmF,EAAA7Q,EAAAqC,OAAA,EACA,OAAAuO,EAAAC,EAAAzQ,EAAAmQ,IAAA7E,GAAAmF,EAAA7Q,EAAA0L,GAAA,GAAA,EAIA,SAAAoG,EAAAC,EAAA3R,GACA,OAAA2R,EAAA1P,OAAA,EAAA0P,EAAAC,OAAA,GAAA,IAAAD,EAAAlP,MAAA,GAAAkP,IACA3R,EAAA,EAAA,IAAA,MAAAA,EAIA,SAAA6R,EAAAF,EAAA3R,EAAA6Q,GACA,IAAAiB,EAAAC,EAGA,GAAA/R,EAAA,EAAA,CAGA,IAAA+R,EAAAlB,EAAA,MAAA7Q,EAAA+R,GAAAlB,GACAc,EAAAI,EAAAJ,OAOA,KAAA3R,GAHA8R,EAAAH,EAAA1P,QAGA,CACA,IAAA8P,EAAAlB,EAAA7Q,GAAA8R,IAAA9R,EAAA+R,GAAAlB,GACAc,GAAAI,OACA/R,EAAA8R,IACAH,EAAAA,EAAAlP,MAAA,EAAAzC,GAAA,IAAA2R,EAAAlP,MAAAzC,IAIA,OAAA2R,GAOAhC,EAppFA,SAAAqC,EAAAC,GACA,IAAAC,EAAAC,EAAAC,EAmhBAC,EA6pBAC,EACAC,EACAC,EACAC,EACAC,EAnrCAC,EAAAhD,EAAAnN,UAAA,CAAAL,YAAAwN,EAAAzN,SAAA,KAAA0Q,QAAA,MACAC,EAAA,IAAAlD,EAAA,GAUAmD,EAAA,GAaAC,EAAA,EAMAC,GAAA,EAIAC,EAAA,GAMAC,GAAA,IAKAC,EAAA,IAGAC,GAAA,EAkBAC,EAAA,EAIAC,EAAA,EAGAC,EAAA,CACAC,iBAAA,IACAC,eAAA,IACAC,UAAA,EACAC,mBAAA,EACAC,uBAAA,IACAC,kBAAA,GAMAC,EAAA,uCAgBA,SAAAnE,EAAAc,EAAAS,GACA,IAAA6C,EAAAnU,EAAAI,EAAAgC,EAAAgS,EAAAlC,EAAAH,EACAX,EAAA1R,KAGA,KAAA0R,aAAArB,GAKA,OAAA,IAAAA,EAAAc,EAAAS,GAGA,GAAA,MAAAA,EAAA,CAGA,GAAAT,aAAAd,EAIA,OAHAqB,EAAAJ,EAAAH,EAAAG,EACAI,EAAAhR,EAAAyQ,EAAAzQ,OACAgR,EAAApR,GAAA6Q,EAAAA,EAAA7Q,GAAA6Q,EAAAhO,QAAAgO,GAMA,IAFAuD,EAAA,iBAAAvD,IAEA,EAAAA,GAAA,EAAA,CAMA,GAHAO,EAAAJ,EAAA,EAAAH,EAAA,GAAAA,GAAAA,GAAA,GAAA,EAGAA,MAAAA,EAAA,CACA,IAAAzQ,EAAA,EAAAgC,EAAAyO,EAAAzO,GAAA,GAAAA,GAAA,GAAAhC,KAGA,OAFAgR,EAAAhR,EAAAA,OACAgR,EAAApR,EAAA,CAAA6Q,IAIAkB,EAAAlB,EAAA,OACA,CACA,IAAAb,EAAAqE,KAAAtC,EAAAlB,EAAA,IAAA,OAAA2B,EAAApB,EAAAW,EAAAqC,GACAhD,EAAAJ,EAAA,IAAAe,EAAAb,WAAA,IAAAa,EAAAA,EAAAlP,MAAA,IAAA,GAAA,OAGA,CAQA,GALA4O,EAAAH,EAAA,EAAA4C,EAAA7R,OAAA,QACA0P,EAAAlB,EAAA,GAIA,IAAAS,EAEA,OAAAgD,EADAlD,EAAA,IAAArB,EAAAc,aAAAd,EAAAc,EAAAkB,GACAmB,EAAA9B,EAAAhR,EAAA,EAAA+S,GAKA,GAFAiB,EAAA,iBAAAvD,EAEA,CAGA,GAAA,EAAAA,GAAA,EAAA,OAAA2B,EAAApB,EAAAW,EAAAqC,EAAA9C,GAKA,GAHAF,EAAAJ,EAAA,EAAAH,EAAA,GAAAkB,EAAAA,EAAAlP,MAAA,IAAA,GAAA,EAGAkN,EAAAtO,OAAAsQ,EAAAxN,QAAA,YAAA,IAAAlC,OAAA,GACA,MAAA4I,MACAoF,EAAAQ,GAIAuD,GAAA,OAEAhD,EAAAJ,EAAA,KAAAe,EAAAb,WAAA,IAAAa,EAAAA,EAAAlP,MAAA,IAAA,GAAA,EAGAyO,EAAA,IAAAA,EAAA,KAAAS,EAAAA,EAAA1O,eAQA,IALA8Q,EAAAD,EAAArR,MAAA,EAAAyO,GACAlR,EAAAgC,EAAA,EAIA8P,EAAAH,EAAA1P,OAAAD,EAAA8P,EAAA9P,IACA,GAAA+R,EAAAjL,QAAAlJ,EAAA+R,EAAAC,OAAA5P,IAAA,EAAA,CACA,GAAA,KAAApC,GAGAoC,EAAAhC,EAAA,CACAA,EAAA8R,EACA,SAIA,OAAAM,EAAApB,EAAAP,EAAA,GAAAuD,EAAA9C,GAIAS,EAAAQ,EAAAR,EAAAT,EAAA,GAAAF,EAAAJ,GAoBA,KAhBA5Q,EAAA2R,EAAA7I,QAAA,OAAA,IAAA6I,EAAAA,EAAAxN,QAAA,IAAA,MAGAnC,EAAA2P,EAAAwC,OAAA,OAAA,GAGAnU,EAAA,IAAAA,EAAAgC,GACAhC,IAAA2R,EAAAlP,MAAAT,EAAA,GACA2P,EAAAA,EAAAyC,UAAA,EAAApS,IACAhC,EAAA,IAGAA,EAAA2R,EAAA1P,QAIAD,EAAA,EAAA,KAAA2P,EAAAb,WAAA9O,GAAAA,KAGA,IAAA8P,EAAAH,EAAA1P,OAAA,KAAA0P,EAAAb,aAAAgB,KAIA,GAFAH,EAAAA,EAAAlP,MAAAT,IAAA8P,GAEA,CAIA,GAHAA,GAAA9P,EAGAgS,GAAArE,EAAAtO,OACAyQ,EAAA,KAAArB,EAAAL,GAAAK,IAAAX,EAAAW,IACA,MAAA5F,MACAoF,EAAAe,EAAAJ,EAAAH,GAMA,IAHAzQ,EAAAA,EAAAgC,EAAA,GAGAmR,EAGAnC,EAAApR,EAAAoR,EAAAhR,EAAA,UAGA,GAAAA,EAAAkT,EAGAlC,EAAApR,EAAA,CAAAoR,EAAAhR,EAAA,OACA,CAWA,GAVAgR,EAAAhR,EAAAA,EACAgR,EAAApR,EAAA,GAMAoC,GAAAhC,EAAA,GAAAmQ,EACAnQ,EAAA,IAAAgC,GAAAmO,GAEAnO,EAAA8P,EAAA,CAGA,IAFA9P,GAAAgP,EAAApR,EAAA+I,MAAAgJ,EAAAlP,MAAA,EAAAT,IAEA8P,GAAA3B,EAAAnO,EAAA8P,GACAd,EAAApR,EAAA+I,MAAAgJ,EAAAlP,MAAAT,EAAAA,GAAAmO,IAGAwB,EAAAA,EAAAlP,MAAAT,GACAA,EAAAmO,EAAAwB,EAAA1P,YAEAD,GAAA8P,EAGA,KAAA9P,IAAA2P,GAAA,KACAX,EAAApR,EAAA+I,MAAAgJ,SAKAX,EAAApR,EAAA,CAAAoR,EAAAhR,EAAA,GA+xBA,SAAAqU,EAAA5D,EAAAzO,EAAAsS,EAAAtP,GACA,IAAAuP,EAAAvU,EAAAwU,EAAA1C,EAAAH,EAKA,GAHA,MAAA2C,EAAAA,EAAAvB,EACA1B,EAAAiD,EAAA,EAAA,IAEA7D,EAAA7Q,EAAA,OAAA6Q,EAAAvO,WAKA,GAHAqS,EAAA9D,EAAA7Q,EAAA,GACA4U,EAAA/D,EAAAzQ,EAEA,MAAAgC,EACA2P,EAAAjB,EAAAD,EAAA7Q,GACA+R,EAAA,GAAA3M,GAAA,GAAAA,GAAAwP,GAAAxB,EACAtB,EAAAC,EAAA6C,GACA3C,EAAAF,EAAA6C,EAAA,UAeA,GAVAxU,GAHAyQ,EAAAyD,EAAA,IAAAvE,EAAAc,GAAAzO,EAAAsS,IAGAtU,EAGA8R,GADAH,EAAAjB,EAAAD,EAAA7Q,IACAqC,OAOA,GAAA+C,GAAA,GAAAA,IAAAhD,GAAAhC,GAAAA,GAAAgT,GAAA,CAGA,KAAAlB,EAAA9P,EAAA2P,GAAA,IAAAG,KACAH,EAAAD,EAAAC,EAAA3R,QAQA,GAJAgC,GAAAwS,EACA7C,EAAAE,EAAAF,EAAA3R,EAAA,KAGAA,EAAA,EAAA8R,GACA,KAAA9P,EAAA,EAAA,IAAA2P,GAAA,IAAA3P,IAAA2P,GAAA,WAGA,IADA3P,GAAAhC,EAAA8R,GACA,EAEA,IADA9R,EAAA,GAAA8R,IAAAH,GAAA,KACA3P,IAAA2P,GAAA,KAMA,OAAAlB,EAAAG,EAAA,GAAA2D,EAAA,IAAA5C,EAAAA,EAKA,SAAA8C,EAAAlU,EAAAmU,GACA,IAAAC,EAAAlE,EACAzO,EAAA,EAKA,IAHAwP,EAAAjR,EAAA,MAAAA,EAAAA,EAAA,IACAoU,EAAA,IAAAhF,EAAApP,EAAA,MAEAyB,EAAAzB,EAAA0B,QAAA,CAIA,KAHAwO,EAAA,IAAAd,EAAApP,EAAAyB,KAGA4O,EAAA,CACA+D,EAAAlE,EACA,MACAiE,EAAAhS,KAAAiS,EAAAlE,KACAkE,EAAAlE,GAIA,OAAAkE,EAQA,SAAAC,EAAAnE,EAAA7Q,EAAAI,GAKA,IAJA,IAAAgC,EAAA,EACAqJ,EAAAzL,EAAAqC,QAGArC,IAAAyL,GAAAzL,EAAAuJ,OAGA,IAAAkC,EAAAzL,EAAA,GAAAyL,GAAA,GAAAA,GAAA,GAAArJ,KAkBA,OAfAhC,EAAAgC,EAAAhC,EAAAmQ,EAAA,GAAAgD,EAGA1C,EAAA7Q,EAAA6Q,EAAAzQ,EAAA,KAGAA,EAAAkT,EAGAzC,EAAA7Q,EAAA,CAAA6Q,EAAAzQ,EAAA,IAEAyQ,EAAAzQ,EAAAA,EACAyQ,EAAA7Q,EAAAA,GAGA6Q,EAyDA,SAAAyD,EAAAlD,EAAA6D,EAAAP,EAAAvJ,GACA,IAAA7H,EAAAlB,EAAAqJ,EAAAC,EAAAmF,EAAAqE,EAAAC,EACA5D,EAAAH,EAAApR,EACAoV,EAAA3E,EAGA,GAAAc,EAAA,CAQAnE,EAAA,CAGA,IAAA9J,EAAA,EAAAoI,EAAA6F,EAAA,GAAA7F,GAAA,GAAAA,GAAA,GAAApI,KAIA,IAHAlB,EAAA6S,EAAA3R,GAGA,EACAlB,GAAAmO,EACA9E,EAAAwJ,EAIAE,GAHAtE,EAAAU,EAAA2D,EAAA,IAGAE,EAAA9R,EAAAmI,EAAA,GAAA,GAAA,OAIA,IAFAyJ,EAAAjF,GAAA7N,EAAA,GAAAmO,KAEAgB,EAAAlP,OAAA,CAEA,IAAA8I,EASA,MAAAiC,EANA,KAAAmE,EAAAlP,QAAA6S,EAAA3D,EAAAxI,KAAA,IACA8H,EAAAsE,EAAA,EACA7R,EAAA,EAEAmI,GADArJ,GAAAmO,GACAA,EAAA,MAIA,CAIA,IAHAM,EAAAnF,EAAA6F,EAAA2D,GAGA5R,EAAA,EAAAoI,GAAA,GAAAA,GAAA,GAAApI,KAUA6R,GAHA1J,GAJArJ,GAAAmO,GAIAA,EAAAjN,GAGA,EAAA,EAAAuN,EAAAuE,EAAA9R,EAAAmI,EAAA,GAAA,GAAA,EAmBA,GAfAN,EAAAA,GAAA8J,EAAA,GAKA,MAAA1D,EAAA2D,EAAA,KAAAzJ,EAAA,EAAAoF,EAAAA,EAAAuE,EAAA9R,EAAAmI,EAAA,IAEAN,EAAAuJ,EAAA,GACAS,GAAAhK,KAAA,GAAAuJ,GAAAA,IAAAtD,EAAAJ,EAAA,EAAA,EAAA,IACAmE,EAAA,GAAA,GAAAA,IAAA,GAAAT,GAAAvJ,GAAA,GAAAuJ,IAGAtS,EAAA,EAAAqJ,EAAA,EAAAoF,EAAAuE,EAAA9R,EAAAmI,GAAA,EAAA8F,EAAA2D,EAAA,IAAA,GAAA,GACAR,IAAAtD,EAAAJ,EAAA,EAAA,EAAA,IAEAiE,EAAA,IAAA1D,EAAA,GAiBA,OAhBAA,EAAAlP,OAAA,EAEA8I,GAGA8J,GAAA7D,EAAAhR,EAAA,EAGAmR,EAAA,GAAA6D,GAAA7E,EAAA0E,EAAA1E,GAAAA,GACAa,EAAAhR,GAAA6U,GAAA,GAIA1D,EAAA,GAAAH,EAAAhR,EAAA,EAGAgR,EAkBA,GAdA,GAAAhP,GACAmP,EAAAlP,OAAA6S,EACAxJ,EAAA,EACAwJ,MAEA3D,EAAAlP,OAAA6S,EAAA,EACAxJ,EAAA0J,EAAA7E,EAAAnO,GAIAmP,EAAA2D,GAAAzJ,EAAA,EAAAyE,EAAAW,EAAAuE,EAAA9R,EAAAmI,GAAA2J,EAAA3J,IAAAC,EAAA,GAIAP,EAEA,OAAA,CAGA,GAAA,GAAA+J,EAAA,CAGA,IAAA9S,EAAA,EAAAqJ,EAAA8F,EAAA,GAAA9F,GAAA,GAAAA,GAAA,GAAArJ,KAEA,IADAqJ,EAAA8F,EAAA,IAAA7F,EACAA,EAAA,EAAAD,GAAA,GAAAA,GAAA,GAAAC,KAGAtJ,GAAAsJ,IACA0F,EAAAhR,IACAmR,EAAA,IAAAjB,IAAAiB,EAAA,GAAA,IAGA,MAGA,GADAA,EAAA2D,IAAAxJ,EACA6F,EAAA2D,IAAA5E,EAAA,MACAiB,EAAA2D,KAAA,EACAxJ,EAAA,EAMA,IAAAtJ,EAAAmP,EAAAlP,OAAA,IAAAkP,IAAAnP,GAAAmP,EAAAhI,QAIA6H,EAAAhR,EAAAmT,EACAnC,EAAApR,EAAAoR,EAAAhR,EAAA,KAGAgR,EAAAhR,EAAAkT,IACAlC,EAAApR,EAAA,CAAAoR,EAAAhR,EAAA,IAIA,OAAAgR,EA+oCA,OAzuEArB,EAAAqC,MAAAA,EAEArC,EAAAsF,SAAA,EACAtF,EAAAuF,WAAA,EACAvF,EAAAwF,WAAA,EACAxF,EAAAyF,YAAA,EACAzF,EAAA0F,cAAA,EACA1F,EAAA2F,gBAAA,EACA3F,EAAA4F,gBAAA,EACA5F,EAAA6F,gBAAA,EACA7F,EAAA8F,iBAAA,EACA9F,EAAA+F,OAAA,EAoCA/F,EAAAgG,OAAAhG,EAAApI,IAAA,SAAAD,GACA,IAAAsO,EAAA9S,EAEA,GAAA,MAAAwE,EAAA,CAEA,GAAA,iBAAAA,EA0HA,MAAAuD,MACAmF,EAAA,oBAAA1I,GArFA,GAlCAA,EAAAuO,eAAAD,EAAA,oBAEAvE,EADAvO,EAAAwE,EAAAsO,GACA,EAAArF,EAAAqF,GACA9C,EAAAhQ,GAKAwE,EAAAuO,eAAAD,EAAA,mBAEAvE,EADAvO,EAAAwE,EAAAsO,GACA,EAAA,EAAAA,GACA7C,EAAAjQ,GAOAwE,EAAAuO,eAAAD,EAAA,oBAEApE,EADA1O,EAAAwE,EAAAsO,KAEAvE,EAAAvO,EAAA,IAAAyN,EAAA,EAAAqF,GACAvE,EAAAvO,EAAA,GAAA,EAAAyN,EAAAqF,GACA5C,EAAAlQ,EAAA,GACAmQ,EAAAnQ,EAAA,KAEAuO,EAAAvO,GAAAyN,EAAAA,EAAAqF,GACA5C,IAAAC,EAAAnQ,EAAA,GAAAA,EAAAA,KAOAwE,EAAAuO,eAAAD,EAAA,SAEA,GAAApE,EADA1O,EAAAwE,EAAAsO,IAEAvE,EAAAvO,EAAA,IAAAyN,GAAA,EAAAqF,GACAvE,EAAAvO,EAAA,GAAA,EAAAyN,EAAAqF,GACA1C,EAAApQ,EAAA,GACAqQ,EAAArQ,EAAA,OACA,CAEA,GADAuO,EAAAvO,GAAAyN,EAAAA,EAAAqF,IACA9S,EAGA,MAAA+H,MACAmF,EAAA4F,EAAA,oBAAA9S,GAHAoQ,IAAAC,EAAArQ,EAAA,GAAAA,EAAAA,GAWA,GAAAwE,EAAAuO,eAAAD,EAAA,UAAA,CAEA,IADA9S,EAAAwE,EAAAsO,QACA9S,EAcA,MAAA+H,MACAmF,EAAA4F,EAAA,uBAAA9S,GAdA,GAAAA,EAAA,CACA,GAAA,oBAAAgT,SAAAA,SACAA,OAAAC,kBAAAD,OAAAE,YAIA,MADA5C,GAAAtQ,EACA+H,MACAmF,EAAA,sBAJAoD,EAAAtQ,OAOAsQ,EAAAtQ,EA0BA,GAhBAwE,EAAAuO,eAAAD,EAAA,iBAEAvE,EADAvO,EAAAwE,EAAAsO,GACA,EAAA,EAAAA,GACAvC,EAAAvQ,GAKAwE,EAAAuO,eAAAD,EAAA,mBAEAvE,EADAvO,EAAAwE,EAAAsO,GACA,EAAArF,EAAAqF,GACAtC,EAAAxQ,GAKAwE,EAAAuO,eAAAD,EAAA,UAAA,CAEA,GAAA,iBADA9S,EAAAwE,EAAAsO,IAEA,MAAA/K,MACAmF,EAAA4F,EAAA,mBAAA9S,GAFAyQ,EAAAzQ,EAOA,GAAAwE,EAAAuO,eAAAD,EAAA,YAAA,CAIA,GAAA,iBAHA9S,EAAAwE,EAAAsO,KAGA,iBAAA3B,KAAAnR,GAGA,MAAA+H,MACAmF,EAAA4F,EAAA,aAAA9S,GAHAgR,EAAAhR,GAeA,MAAA,CACAgQ,eAAAA,EACAC,cAAAA,EACAkD,eAAA,CAAAjD,EAAAC,GACAiD,MAAA,CAAAhD,EAAAC,GACAC,OAAAA,EACAC,YAAAA,EACAC,cAAAA,EACAC,OAAAA,EACAO,SAAAA,IAUAnE,EAAAwG,YAAA,SAAArT,GACA,OAAAA,aAAA6M,GAAA7M,IAAA,IAAAA,EAAAsT,eAAA,GASAzG,EAAA0G,QAAA1G,EAAA4B,IAAA,WACA,OAAAkD,EAAAnS,UAAAqQ,EAAA2D,KASA3G,EAAA4G,QAAA5G,EAAA2B,IAAA,WACA,OAAAmD,EAAAnS,UAAAqQ,EAAA6D,KAcA7G,EAAA8G,QAOApE,EANA,iBAMA1H,KAAA8L,SAAA,QACA,WAAA,OAAA3G,EAPA,iBAOAnF,KAAA8L,WACA,WAAA,OAAA,SAAA,WAAA9L,KAAA8L,SAAA,IACA,QAAA9L,KAAA8L,SAAA,IAEA,SAAAC,GACA,IAAA/F,EAAAO,EAAAlR,EAAAsL,EAAAxI,EACAd,EAAA,EACApC,EAAA,GACA+W,EAAA,IAAAhH,EAAAkD,GAOA,GALA,MAAA6D,EAAAA,EAAA5D,EACAzB,EAAAqF,EAAA,EAAAnG,GAEAjF,EAAAuE,EAAA6G,EAAAvG,GAEAiD,EAGA,GAAA0C,OAAAC,gBAAA,CAIA,IAFApF,EAAAmF,OAAAC,gBAAA,IAAAa,YAAAtL,GAAA,IAEAtJ,EAAAsJ,IAQAxI,EAAA,OAAA6N,EAAA3O,IAAA2O,EAAA3O,EAAA,KAAA,MAMA,MACAkP,EAAA4E,OAAAC,gBAAA,IAAAa,YAAA,IACAjG,EAAA3O,GAAAkP,EAAA,GACAP,EAAA3O,EAAA,GAAAkP,EAAA,KAKAtR,EAAA+I,KAAA7F,EAAA,MACAd,GAAA,GAGAA,EAAAsJ,EAAA,MAGA,CAAA,IAAAwK,OAAAE,YA2BA,MADA5C,GAAA,EACAvI,MACAmF,EAAA,sBAvBA,IAFAW,EAAAmF,OAAAE,YAAA1K,GAAA,GAEAtJ,EAAAsJ,IAMAxI,EAAA,iBAAA,GAAA6N,EAAA3O,IAAA,cAAA2O,EAAA3O,EAAA,GACA,WAAA2O,EAAA3O,EAAA,GAAA,SAAA2O,EAAA3O,EAAA,IACA2O,EAAA3O,EAAA,IAAA,KAAA2O,EAAA3O,EAAA,IAAA,GAAA2O,EAAA3O,EAAA,KAEA,KACA8T,OAAAE,YAAA,GAAAa,KAAAlG,EAAA3O,IAIApC,EAAA+I,KAAA7F,EAAA,MACAd,GAAA,GAGAA,EAAAsJ,EAAA,EASA,IAAA8H,EAEA,KAAApR,EAAAsJ,IACAxI,EAAAuP,KACA,OAAAzS,EAAAoC,KAAAc,EAAA,MAcA,IAVAwI,EAAA1L,IAAAoC,GACA0U,GAAAvG,EAGA7E,GAAAoL,IACA5T,EAAAuN,EAAAF,EAAAuG,GACA9W,EAAAoC,GAAA8N,EAAAxE,EAAAxI,GAAAA,GAIA,IAAAlD,EAAAoC,GAAApC,EAAAuJ,MAAAnH,KAGA,GAAAA,EAAA,EACApC,EAAA,CAAAI,EAAA,OACA,CAGA,IAAAA,GAAA,EAAA,IAAAJ,EAAA,GAAAA,EAAAyJ,OAAA,EAAA,GAAArJ,GAAAmQ,GAGA,IAAAnO,EAAA,EAAAc,EAAAlD,EAAA,GAAAkD,GAAA,GAAAA,GAAA,GAAAd,KAGAA,EAAAmO,IAAAnQ,GAAAmQ,EAAAnO,GAKA,OAFA2U,EAAA3W,EAAAA,EACA2W,EAAA/W,EAAAA,EACA+W,IASAxE,EAAA,WAQA,SAAA2E,EAAAnF,EAAAoF,EAAAC,EAAAjD,GAOA,IANA,IAAA1I,EAEA4L,EADAC,EAAA,CAAA,GAEAlV,EAAA,EACA8P,EAAAH,EAAA1P,OAEAD,EAAA8P,GAAA,CACA,IAAAmF,EAAAC,EAAAjV,OAAAgV,IAAAC,EAAAD,IAAAF,GAIA,IAFAG,EAAA,IAAAnD,EAAAjL,QAAA6I,EAAAC,OAAA5P,MAEAqJ,EAAA,EAAAA,EAAA6L,EAAAjV,OAAAoJ,IAEA6L,EAAA7L,GAAA2L,EAAA,IACA,MAAAE,EAAA7L,EAAA,KAAA6L,EAAA7L,EAAA,GAAA,GACA6L,EAAA7L,EAAA,IAAA6L,EAAA7L,GAAA2L,EAAA,EACAE,EAAA7L,IAAA2L,GAKA,OAAAE,EAAAC,UAMA,OAAA,SAAAxF,EAAAoF,EAAAC,EAAAI,EAAAC,GACA,IAAAtD,EAAA7Q,EAAAlD,EAAAsL,EAAAP,EAAAiG,EAAAG,EAAAF,EACAjP,EAAA2P,EAAA7I,QAAA,KACA4N,EAAA5D,EACAwB,EAAAvB,EA+BA,IA5BA/Q,GAAA,IACAsJ,EAAAgI,EAGAA,EAAA,EACA3B,EAAAA,EAAAxN,QAAA,IAAA,IAEA6M,GADAC,EAAA,IAAAtB,EAAAoH,IACAnM,IAAA+G,EAAA1P,OAAAD,GACAsR,EAAAhI,EAKA2F,EAAArR,EAAAkX,EAAAjF,EAAAnB,EAAAM,EAAApR,GAAAoR,EAAAhR,EAAA,KACA,GAAAgX,EAxDA,cAyDA/F,EAAAjR,EAAAiR,EAAArR,EAAAqC,QAUAjC,EAAAsL,GALA6F,EAAA2F,EAAAnF,EAAAoF,EAAAC,EAAAK,GACAtD,EAAAD,EA/DA,eAgEAC,EAhEA,aAgEAD,KAGA7R,OAGA,GAAAkP,IAAA7F,GAAA6F,EAAAhI,OAGA,IAAAgI,EAAA,GAAA,OAAA4C,EAAAnC,OAAA,GAqCA,GAlCA5P,EAAA,IACAhC,GAEAgR,EAAApR,EAAAuR,EACAH,EAAAhR,EAAAA,EAGAgR,EAAAJ,EAAAwG,EAEAjG,GADAH,EAAAkB,EAAAlB,EAAAC,EAAAyF,EAAApC,EAAA0C,IACApX,EACAmL,EAAAiG,EAAAjG,EACA/K,EAAAgR,EAAAhR,GASAgC,EAAAmP,EAHAjO,EAAAlD,EAAA0W,EAAA,GAOApL,EAAA0L,EAAA,EACAjM,EAAAA,GAAA7H,EAAA,GAAA,MAAAiO,EAAAjO,EAAA,GAEA6H,EAAAuJ,EAAA,GAAA,MAAAtS,GAAA+I,KAAA,GAAAuJ,GAAAA,IAAAtD,EAAAJ,EAAA,EAAA,EAAA,IACA5O,EAAAsJ,GAAAtJ,GAAAsJ,IAAA,GAAAgJ,GAAAvJ,GAAA,GAAAuJ,GAAA,EAAAnD,EAAAjO,EAAA,IACAoR,IAAAtD,EAAAJ,EAAA,EAAA,EAAA,IAKA1N,EAAA,IAAAiO,EAAA,GAGAQ,EAAA5G,EAAA8G,EAAAkC,EAAAnC,OAAA,IAAA8E,EAAA3C,EAAAnC,OAAA,IACAmC,EAAAnC,OAAA,OACA,CAMA,GAHAT,EAAAlP,OAAAiB,EAGA6H,EAGA,MAAAiM,IAAA7F,IAAAjO,GAAA8T,GACA7F,EAAAjO,GAAA,EAEAA,MACAlD,EACAmR,EAAA,CAAA,GAAAmG,OAAAnG,IAMA,IAAA7F,EAAA6F,EAAAlP,QAAAkP,IAAA7F,KAGA,IAAAtJ,EAAA,EAAA2P,EAAA,GAAA3P,GAAAsJ,EAAAqG,GAAAoC,EAAAnC,OAAAT,EAAAnP,OAGA2P,EAAAE,EAAAF,EAAA3R,EAAA+T,EAAAnC,OAAA,IAIA,OAAAD,GAlJA,GAwJAO,EAAA,WAGA,SAAAqF,EAAAvG,EAAA1F,EAAAkM,GACA,IAAA7C,EAAA8C,EAAAC,EAAAC,EACAC,EAAA,EACA5V,EAAAgP,EAAA/O,OACA4V,EAAAvM,EAAAgF,EACAwH,EAAAxM,EAAAgF,EAAA,EAEA,IAAAU,EAAAA,EAAAvO,QAAAT,KAKA4V,IADAH,EAAAI,GAHAH,EAAA1G,EAAAhP,GAAAsO,IAEAqE,EAAAmD,EAAAJ,GADAC,EAAA3G,EAAAhP,GAAAsO,EAAA,GACAuH,GACAvH,EAAAA,EAAAsH,GACAJ,EAAA,IAAA7C,EAAArE,EAAA,GAAAwH,EAAAH,EACA3G,EAAAhP,GAAAyV,EAAAD,EAKA,OAFAI,IAAA5G,EAAA,CAAA4G,GAAAN,OAAAtG,IAEAA,EAGA,SAAAD,EAAAJ,EAAAO,EAAA6G,EAAAC,GACA,IAAAhW,EAAAiW,EAEA,GAAAF,GAAAC,EACAC,EAAAF,EAAAC,EAAA,GAAA,OAGA,IAAAhW,EAAAiW,EAAA,EAAAjW,EAAA+V,EAAA/V,IAEA,GAAA2O,EAAA3O,IAAAkP,EAAAlP,GAAA,CACAiW,EAAAtH,EAAA3O,GAAAkP,EAAAlP,GAAA,GAAA,EACA,MAKA,OAAAiW,EAGA,SAAAC,EAAAvH,EAAAO,EAAA6G,EAAAP,GAIA,IAHA,IAAAxV,EAAA,EAGA+V,KACApH,EAAAoH,IAAA/V,EACAA,EAAA2O,EAAAoH,GAAA7G,EAAA6G,GAAA,EAAA,EACApH,EAAAoH,GAAA/V,EAAAwV,EAAA7G,EAAAoH,GAAA7G,EAAA6G,GAIA,MAAApH,EAAA,IAAAA,EAAA1O,OAAA,EAAA0O,EAAAtH,OAAA,EAAA,KAIA,OAAA,SAAA2H,EAAAC,EAAAyF,EAAApC,EAAAkD,GACA,IAAAS,EAAAjY,EAAAgC,EAAAmW,EAAA1H,EAAA2H,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EACAC,EAAAC,EACAnI,EAAAI,EAAAJ,GAAAK,EAAAL,EAAA,GAAA,EACAO,EAAAH,EAAApR,EACAwR,EAAAH,EAAArR,EAGA,KAAAuR,GAAAA,EAAA,IAAAC,GAAAA,EAAA,IAEA,OAAA,IAAAzB,EAGAqB,EAAAJ,GAAAK,EAAAL,IAAAO,GAAAC,GAAAD,EAAA,IAAAC,EAAA,GAAAA,GAGAD,GAAA,GAAAA,EAAA,KAAAC,EAAA,EAAAR,EAAAA,EAAA,EAHAoI,KAoBA,IAZAT,GADAD,EAAA,IAAA3I,EAAAiB,IACAhR,EAAA,GAEAgR,EAAA8F,GADA1W,EAAAgR,EAAAhR,EAAAiR,EAAAjR,GACA,EAEAwX,IACAA,EAAAtH,EACAlQ,EAAAwQ,EAAAQ,EAAAhR,EAAAmQ,GAAAK,EAAAS,EAAAjR,EAAAmQ,GACAS,EAAAA,EAAAT,EAAA,GAKAnO,EAAA,EAAAoP,EAAApP,KAAAmP,EAAAnP,IAAA,GAAAA,KAIA,GAFAoP,EAAApP,IAAAmP,EAAAnP,IAAA,IAAAhC,IAEA4Q,EAAA,EACA2H,EAAA5P,KAAA,GACAwP,GAAA,MACA,CAwBA,IAvBAS,EAAAzH,EAAAlP,OACA6W,EAAA1H,EAAAnP,OACAD,EAAA,EACA4O,GAAA,GAIAH,EAAAX,EAAA0H,GAAApG,EAAA,GAAA,KAIA,IACAA,EAAAmG,EAAAnG,EAAAX,EAAA+G,GACArG,EAAAoG,EAAApG,EAAAV,EAAA+G,GACAsB,EAAA1H,EAAAnP,OACA2W,EAAAzH,EAAAlP,QAGA0W,EAAAG,EAEAL,GADAD,EAAArH,EAAA1O,MAAA,EAAAqW,IACA7W,OAGAwW,EAAAK,EAAAN,EAAAC,KAAA,GACAM,EAAA3H,EAAA3O,QACAsW,EAAA,CAAA,GAAAzB,OAAAyB,GACAF,EAAAzH,EAAA,GACAA,EAAA,IAAAoG,EAAA,GAAAqB,IAIA,EAAA,CAOA,GANApI,EAAA,GAGAwH,EAAAlH,EAAAK,EAAAoH,EAAAM,EAAAL,IAGA,EAAA,CAqBA,GAjBAC,EAAAF,EAAA,GACAM,GAAAL,IAAAC,EAAAA,EAAAlB,GAAAgB,EAAA,IAAA,KAGA/H,EAAAX,EAAA4I,EAAAG,IAaA,EAcA,IAXApI,GAAA+G,IAAA/G,EAAA+G,EAAA,GAIAa,GADAD,EAAAb,EAAAnG,EAAAX,EAAA+G,IACAvV,OACAwW,EAAAD,EAAAvW,OAMA,GAAA8O,EAAAqH,EAAAI,EAAAH,EAAAI,IACAhI,IAGAyH,EAAAE,EAAAU,EAAAT,EAAAU,EAAA3H,EAAAiH,EAAAb,GACAa,EAAAD,EAAAnW,OACAgW,EAAA,OAQA,GAAAxH,IAGAwH,EAAAxH,EAAA,GAKA4H,GADAD,EAAAhH,EAAA3O,SACAR,OAUA,GAPAoW,EAAAI,IAAAL,EAAA,CAAA,GAAAd,OAAAc,IAGAF,EAAAM,EAAAJ,EAAAK,EAAAjB,GACAiB,EAAAD,EAAAvW,QAGA,GAAAgW,EAMA,KAAAlH,EAAAK,EAAAoH,EAAAM,EAAAL,GAAA,GACAhI,IAGAyH,EAAAM,EAAAM,EAAAL,EAAAM,EAAA3H,EAAAqH,EAAAjB,GACAiB,EAAAD,EAAAvW,YAGA,IAAAgW,IACAxH,IACA+H,EAAA,CAAA,IAIAD,EAAAvW,KAAAyO,EAGA+H,EAAA,GACAA,EAAAC,KAAAtH,EAAAwH,IAAA,GAEAH,EAAA,CAAArH,EAAAwH,IACAF,EAAA,UAEAE,IAAAC,GAAA,MAAAJ,EAAA,KAAA5H,KAEAuH,EAAA,MAAAK,EAAA,GAGAD,EAAA,IAAAA,EAAAlP,OAAA,EAAA,GAGA,GAAAmO,GAAAtH,EAAA,CAGA,IAAAlO,EAAA,EAAA4O,EAAA2H,EAAA,GAAA3H,GAAA,GAAAA,GAAA,GAAA5O,KAEAkS,EAAAoE,EAAA5B,GAAA4B,EAAAtY,EAAAgC,EAAAhC,EAAAmQ,EAAA,GAAA,EAAAmE,EAAA6D,QAIAG,EAAAtY,EAAAA,EACAsY,EAAAvN,GAAAoN,EAGA,OAAAG,GA9PA,GAkYAhG,EAAA,8BACAC,EAAA,cACAC,EAAA,cACAC,EAAA,qBACAC,EAAA,6BALAN,EAOA,SAAApB,EAAAW,EAAAqC,EAAA9C,GACA,IAAAsG,EACA5G,EAAAoD,EAAArC,EAAAA,EAAAxN,QAAAuO,EAAA,IAGA,GAAAD,EAAAwB,KAAArD,GACAI,EAAAJ,EAAA7N,MAAA6N,GAAA,KAAAA,EAAA,GAAA,EAAA,EACAI,EAAApR,EAAAoR,EAAAhR,EAAA,SACA,CACA,IAAAgU,IAGApD,EAAAA,EAAAzM,QAAAmO,EAAA,SAAAqC,EAAAsE,EAAAC,GAEA,OADA1B,EAAA,MAAA0B,EAAAA,EAAAjW,eAAA,GAAA,KAAAiW,EAAA,EAAA,EACAhI,GAAAA,GAAAsG,EAAA7C,EAAAsE,IAGA/H,IACAsG,EAAAtG,EAGAN,EAAAA,EAAAzM,QAAAoO,EAAA,MAAApO,QAAAqO,EAAA,SAGAb,GAAAf,GAAA,OAAA,IAAAjB,EAAAiB,EAAA4G,GAKA,GAAA7H,EAAAtO,MACA,MAAAwJ,MACAmF,EAAA,SAAAkB,EAAA,SAAAA,EAAA,IAAA,YAAAS,GAIAX,EAAApR,EAAAoR,EAAAhR,EAAAgR,EAAAJ,EAAA,OA8KA+B,EAAAwG,cAAAxG,EAAAyG,IAAA,WACA,IAAApI,EAAA,IAAArB,EAAArQ,MAEA,OADA0R,EAAAJ,EAAA,IAAAI,EAAAJ,EAAA,GACAI,GAWA2B,EAAA0G,WAAA,SAAApI,EAAAC,GACA,OAAAH,EAAAzR,KAAA,IAAAqQ,EAAAsB,EAAAC,KAiBAyB,EAAA2G,cAAA3G,EAAA+D,GAAA,SAAAA,EAAApC,GACA,IAAA1U,EAAA6Q,EAAA3N,EACAkO,EAAA1R,KAEA,GAAA,MAAAoX,EAKA,OAJArF,EAAAqF,EAAA,EAAAnG,GACA,MAAA+D,EAAAA,EAAAvB,EACA1B,EAAAiD,EAAA,EAAA,GAEAJ,EAAA,IAAAvE,EAAAqB,GAAA0F,EAAA1F,EAAAhR,EAAA,EAAAsU,GAGA,KAAA1U,EAAAoR,EAAApR,GAAA,OAAA,KAIA,GAHA6Q,IAAA3N,EAAAlD,EAAAqC,OAAA,GAAAuO,EAAAlR,KAAAU,EAAAmQ,IAAAA,EAGArN,EAAAlD,EAAAkD,GAAA,KAAAA,EAAA,IAAA,EAAAA,GAAA,GAAA2N,KAGA,OAFAA,EAAA,IAAAA,EAAA,GAEAA,GAwBAkC,EAAA4G,UAAA5G,EAAAT,IAAA,SAAAjB,EAAAC,GACA,OAAAgB,EAAA5S,KAAA,IAAAqQ,EAAAsB,EAAAC,GAAA4B,EAAAC,IAQAJ,EAAA6G,mBAAA7G,EAAA8G,KAAA,SAAAxI,EAAAC,GACA,OAAAgB,EAAA5S,KAAA,IAAAqQ,EAAAsB,EAAAC,GAAA,EAAA,IAmBAyB,EAAA+G,gBAAA/G,EAAA/H,IAAA,SAAA6F,EAAAkE,GACA,IAAAgF,EAAAC,EAAAtO,EAAAuO,EAAAC,EAAAC,EAAA9I,EACAD,EAAA1R,KAKA,IAHAmR,EAAA,IAAAd,EAAAc,IAGA7Q,IAAA6Q,EAAAuJ,YACA,MAAAnP,MACAmF,EAAA,4BAAAS,GASA,GANA,MAAAkE,IAAAA,EAAA,IAAAhF,EAAAgF,IAGAkF,EAAApJ,EAAAzQ,EAAA,IAGAgR,EAAApR,IAAAoR,EAAApR,EAAA,IAAA,GAAAoR,EAAApR,EAAA,KAAAoR,EAAAhR,GAAA,GAAAgR,EAAApR,EAAAqC,SAAAwO,EAAA7Q,IAAA6Q,EAAA7Q,EAAA,GAKA,OADAqR,EAAA,IAAAtB,EAAAhF,KAAAC,KAAAoG,EAAA4B,UAAAiH,EAAA,EAAApI,EAAAhB,IAAAA,IACAkE,EAAA1D,EAAAgJ,IAAAtF,GAAA1D,EAKA,GAFA6I,EAAArJ,EAAAG,EAAA,EAEA+D,EAAA,CAGA,GAAAA,EAAA/U,GAAA+U,EAAA/U,EAAA,IAAA+U,EAAA/D,EAAA,OAAA,IAAAjB,EAAAqJ,MAEAY,GAAAE,GAAA9I,EAAAgJ,aAAArF,EAAAqF,eAEAhJ,EAAAA,EAAAiJ,IAAAtF,QAIA,CAAA,GAAAlE,EAAAzQ,EAAA,IAAAgR,EAAAhR,EAAA,GAAAgR,EAAAhR,GAAA,IAAA,GAAAgR,EAAAhR,EAEAgR,EAAApR,EAAA,GAAA,GAAAia,GAAA7I,EAAApR,EAAA,IAAA,KAEAoR,EAAApR,EAAA,GAAA,MAAAia,GAAA7I,EAAApR,EAAA,IAAA,YASA,OANA0L,EAAA0F,EAAAJ,EAAA,GAAAa,EAAAhB,IAAA,EAAA,EAGAO,EAAAhR,GAAA,IAAAsL,EAAA,EAAAA,GAGA,IAAAqE,EAAAmK,EAAA,EAAAxO,EAAAA,GAEAgI,IAKAhI,EAAAuE,EAAAyD,EAAAnD,EAAA,IAeA,IAZA0J,GACAF,EAAA,IAAAhK,EAAA,IACAoK,EAAAtI,EAAAhB,IAEAsJ,EAAAtJ,EAAA,EAGAqJ,IAAArJ,EAAAG,EAAA,GAEAK,EAAA,IAAAtB,EAAAkD,KAGA,CAEA,GAAAkH,EAAA,CAEA,KADA9I,EAAAA,EAAAiJ,MAAAlJ,IACApR,EAAA,MAEA0L,EACA2F,EAAArR,EAAAqC,OAAAqJ,IAAA2F,EAAArR,EAAAqC,OAAAqJ,GACAsO,IACA3I,EAAAA,EAAAgJ,IAAAtF,IAIA,GAAAkF,EAAA,CAGA,GADA3F,EADAzD,EAAAA,EAAAyJ,MAAAP,GACAlJ,EAAAzQ,EAAA,EAAA,IACAyQ,EAAA7Q,EAAA,GAAA,MACAia,EAAApJ,EAAAzQ,EAAA,GACA+Z,EAAAtI,EAAAhB,OACA,CAEA,KADAA,EAAAX,EAAAW,EAAA,IACA,MACAsJ,EAAAtJ,EAAA,EAGAO,EAAAA,EAAAkJ,MAAAlJ,GAEA1F,EACA0F,EAAApR,GAAAoR,EAAApR,EAAAqC,OAAAqJ,IAAA0F,EAAApR,EAAAqC,OAAAqJ,GACAsO,IACA5I,EAAAA,EAAAiJ,IAAAtF,IAIA,OAAAiF,EAAA3I,GACA6I,IAAA7I,EAAA4B,EAAAX,IAAAjB,IAEA0D,EAAA1D,EAAAgJ,IAAAtF,GAAArJ,EAAA4I,EAAAjD,EAAAqC,EAAAP,OA9GAoF,GA8GAlH,IAYA0B,EAAAwH,aAAA,SAAA7F,GACA,IAAA7D,EAAA,IAAAd,EAAArQ,MAGA,OAFA,MAAAgV,EAAAA,EAAAvB,EACA1B,EAAAiD,EAAA,EAAA,GACAJ,EAAAzD,EAAAA,EAAAzQ,EAAA,EAAAsU,IAQA3B,EAAAyH,UAAAzH,EAAA0H,GAAA1H,EAAA2H,OAAA,SAAArJ,EAAAC,GACA,OAAA,IAAAH,EAAAzR,KAAA,IAAAqQ,EAAAsB,EAAAC,KAOAyB,EAAA4H,SAAA,WACA,QAAAjb,KAAAM,GAQA+S,EAAA6H,cAAA7H,EAAA6D,GAAA,SAAAvF,EAAAC,GACA,OAAAH,EAAAzR,KAAA,IAAAqQ,EAAAsB,EAAAC,IAAA,GAQAyB,EAAA8H,uBAAA9H,EAAA+H,IAAA,SAAAzJ,EAAAC,GACA,OAAA,KAAAA,EAAAH,EAAAzR,KAAA,IAAAqQ,EAAAsB,EAAAC,MAAA,IAAAA,GAQAyB,EAAAqH,UAAA,WACA,QAAA1a,KAAAM,GAAA4Q,EAAAlR,KAAAU,EAAAmQ,GAAA7Q,KAAAM,EAAAqC,OAAA,GAQA0Q,EAAAgI,WAAAhI,EAAA2D,GAAA,SAAArF,EAAAC,GACA,OAAAH,EAAAzR,KAAA,IAAAqQ,EAAAsB,EAAAC,IAAA,GAQAyB,EAAAiI,oBAAAjI,EAAAkI,IAAA,SAAA5J,EAAAC,GACA,OAAA,KAAAA,EAAAH,EAAAzR,KAAA,IAAAqQ,EAAAsB,EAAAC,MAAA,IAAAA,GAOAyB,EAAA5P,MAAA,WACA,OAAAzD,KAAAsR,GAOA+B,EAAAmI,WAAA,WACA,OAAAxb,KAAAsR,EAAA,GAOA+B,EAAAoI,WAAA,WACA,OAAAzb,KAAAsR,EAAA,GAOA+B,EAAAqI,OAAA,WACA,QAAA1b,KAAAM,GAAA,GAAAN,KAAAM,EAAA,IAwBA+S,EAAAsI,MAAA,SAAAhK,EAAAC,GACA,IAAAlP,EAAAqJ,EAAAhI,EAAA6X,EACAlK,EAAA1R,KACAqR,EAAAK,EAAAJ,EAMA,GAHAM,GADAD,EAAA,IAAAtB,EAAAsB,EAAAC,IACAN,GAGAD,IAAAO,EAAA,OAAA,IAAAvB,EAAAqJ,KAGA,GAAArI,GAAAO,EAEA,OADAD,EAAAL,GAAAM,EACAF,EAAAmK,KAAAlK,GAGA,IAAAmK,EAAApK,EAAAhR,EAAAmQ,EACAkL,EAAApK,EAAAjR,EAAAmQ,EACAgB,EAAAH,EAAApR,EACAwR,EAAAH,EAAArR,EAEA,IAAAwb,IAAAC,EAAA,CAGA,IAAAlK,IAAAC,EAAA,OAAAD,GAAAF,EAAAL,GAAAM,EAAAD,GAAA,IAAAtB,EAAAyB,EAAAJ,EAAAgI,KAGA,IAAA7H,EAAA,KAAAC,EAAA,GAGA,OAAAA,EAAA,IAAAH,EAAAL,GAAAM,EAAAD,GAAA,IAAAtB,EAAAwB,EAAA,GAAAH,EAGA,GAAA+B,GAAA,EAAA,GASA,GALAqI,EAAA5K,EAAA4K,GACAC,EAAA7K,EAAA6K,GACAlK,EAAAA,EAAA1O,QAGAkO,EAAAyK,EAAAC,EAAA,CAaA,KAXAH,EAAAvK,EAAA,IACAA,GAAAA,EACAtN,EAAA8N,IAEAkK,EAAAD,EACA/X,EAAA+N,GAGA/N,EAAA8T,UAGAjG,EAAAP,EAAAO,IAAA7N,EAAAsF,KAAA,IACAtF,EAAA8T,eAMA,IAFA9L,GAAA6P,GAAAvK,EAAAQ,EAAAlP,SAAAiP,EAAAE,EAAAnP,SAAA0O,EAAAO,EAEAP,EAAAO,EAAA,EAAAA,EAAA7F,EAAA6F,IAEA,GAAAC,EAAAD,IAAAE,EAAAF,GAAA,CACAgK,EAAA/J,EAAAD,GAAAE,EAAAF,GACA,MAYA,GANAgK,IAAA7X,EAAA8N,EAAAA,EAAAC,EAAAA,EAAA/N,EAAA4N,EAAAL,GAAAK,EAAAL,IAEAM,GAAA7F,EAAA+F,EAAAnP,SAAAD,EAAAmP,EAAAlP,SAIA,EAAA,KAAAiP,IAAAC,EAAAnP,KAAA,GAIA,IAHAkP,EAAAhB,EAAA,EAGA7E,EAAAsF,GAAA,CAEA,GAAAQ,IAAA9F,GAAA+F,EAAA/F,GAAA,CACA,IAAArJ,EAAAqJ,EAAArJ,IAAAmP,IAAAnP,GAAAmP,EAAAnP,GAAAkP,KACAC,EAAAnP,GACAmP,EAAA9F,IAAA6E,EAGAiB,EAAA9F,IAAA+F,EAAA/F,GAIA,KAAA,GAAA8F,EAAA,GAAAA,EAAA9H,OAAA,EAAA,KAAAgS,GAGA,OAAAlK,EAAA,GAWAyD,EAAA3D,EAAAE,EAAAkK,IAPApK,EAAAL,EAAA,GAAAmC,GAAA,EAAA,EACA9B,EAAArR,EAAA,CAAAqR,EAAAjR,EAAA,GACAiR,IA8BA0B,EAAA2I,OAAA3I,EAAAsH,IAAA,SAAAhJ,EAAAC,GACA,IAAAoH,EAAA1H,EACAI,EAAA1R,KAKA,OAHA2R,EAAA,IAAAtB,EAAAsB,EAAAC,IAGAF,EAAApR,IAAAqR,EAAAL,GAAAK,EAAArR,IAAAqR,EAAArR,EAAA,GACA,IAAA+P,EAAAqJ,MAGA/H,EAAArR,GAAAoR,EAAApR,IAAAoR,EAAApR,EAAA,GACA,IAAA+P,EAAAqB,IAGA,GAAAqC,GAIAzC,EAAAK,EAAAL,EACAK,EAAAL,EAAA,EACA0H,EAAApG,EAAAlB,EAAAC,EAAA,EAAA,GACAA,EAAAL,EAAAA,EACA0H,EAAA1H,GAAAA,GAEA0H,EAAApG,EAAAlB,EAAAC,EAAA,EAAAoC,IAGApC,EAAAD,EAAAiK,MAAA3C,EAAA4B,MAAAjJ,KAGArR,EAAA,IAAA,GAAAyT,IAAApC,EAAAL,EAAAI,EAAAJ,GAEAK,IAwBA0B,EAAA4I,aAAA5I,EAAAuH,MAAA,SAAAjJ,EAAAC,GACA,IAAAtR,EAAAI,EAAAgC,EAAAqJ,EAAAC,EAAAqJ,EAAA6G,EAAA9D,EAAAC,EAAA8D,EAAAC,EAAAC,EAAAC,EACApE,EAAAqE,EACA7K,EAAA1R,KACA6R,EAAAH,EAAApR,EACAwR,GAAAH,EAAA,IAAAtB,EAAAsB,EAAAC,IAAAtR,EAGA,KAAAuR,GAAAC,GAAAD,EAAA,IAAAC,EAAA,IAmBA,OAhBAJ,EAAAJ,IAAAK,EAAAL,GAAAO,IAAAA,EAAA,KAAAC,GAAAA,IAAAA,EAAA,KAAAD,EACAF,EAAArR,EAAAqR,EAAAjR,EAAAiR,EAAAL,EAAA,MAEAK,EAAAL,GAAAI,EAAAJ,EAGAO,GAAAC,GAKAH,EAAArR,EAAA,CAAA,GACAqR,EAAAjR,EAAA,GALAiR,EAAArR,EAAAqR,EAAAjR,EAAA,MASAiR,EAYA,IATAjR,EAAAwQ,EAAAQ,EAAAhR,EAAAmQ,GAAAK,EAAAS,EAAAjR,EAAAmQ,GACAc,EAAAL,GAAAI,EAAAJ,GACA4K,EAAArK,EAAAlP,SACAwZ,EAAArK,EAAAnP,UAGA2Z,EAAAzK,EAAAA,EAAAC,EAAAA,EAAAwK,EAAA5Z,EAAAwZ,EAAAA,EAAAC,EAAAA,EAAAzZ,GAGAA,EAAAwZ,EAAAC,EAAAG,EAAA,GAAA5Z,IAAA4Z,EAAAjT,KAAA,IAKA,IAHA6O,EAAAtH,EACA2L,EAAAvL,EAEAtO,EAAAyZ,IAAAzZ,GAAA,GAAA,CAKA,IAJApC,EAAA,EACA8b,EAAAtK,EAAApP,GAAA6Z,EACAF,EAAAvK,EAAApP,GAAA6Z,EAAA,EAEAxQ,EAAArJ,GAAAsJ,EAAAkQ,GAAAnQ,EAAArJ,GAKApC,IADA8X,EAAAgE,GAHAhE,EAAAvG,IAAA7F,GAAAuQ,IAEAlH,EAAAgH,EAAAjE,GADAC,EAAAxG,EAAA7F,GAAAuQ,EAAA,GACAH,GACAG,EAAAA,EAAAD,EAAAvQ,GAAAzL,GACA4X,EAAA,IAAA7C,EAAAkH,EAAA,GAAAF,EAAAhE,EACAiE,EAAAvQ,KAAAqM,EAAAF,EAGAoE,EAAAvQ,GAAAzL,EASA,OANAA,IACAI,EAEA4b,EAAAvS,OAAA,EAAA,GAGAuL,EAAA3D,EAAA2K,EAAA5b,IAQA2S,EAAAmJ,QAAA,WACA,IAAA9K,EAAA,IAAArB,EAAArQ,MAEA,OADA0R,EAAAJ,GAAAI,EAAAJ,GAAA,KACAI,GAwBA2B,EAAAwI,KAAA,SAAAlK,EAAAC,GACA,IAAA7N,EACA2N,EAAA1R,KACAqR,EAAAK,EAAAJ,EAMA,GAHAM,GADAD,EAAA,IAAAtB,EAAAsB,EAAAC,IACAN,GAGAD,IAAAO,EAAA,OAAA,IAAAvB,EAAAqJ,KAGA,GAAArI,GAAAO,EAEA,OADAD,EAAAL,GAAAM,EACAF,EAAAiK,MAAAhK,GAGA,IAAAmK,EAAApK,EAAAhR,EAAAmQ,EACAkL,EAAApK,EAAAjR,EAAAmQ,EACAgB,EAAAH,EAAApR,EACAwR,EAAAH,EAAArR,EAEA,IAAAwb,IAAAC,EAAA,CAGA,IAAAlK,IAAAC,EAAA,OAAA,IAAAzB,EAAAgB,EAAA,GAIA,IAAAQ,EAAA,KAAAC,EAAA,GAAA,OAAAA,EAAA,GAAAH,EAAA,IAAAtB,EAAAwB,EAAA,GAAAH,EAAA,EAAAL,GAQA,GALAyK,EAAA5K,EAAA4K,GACAC,EAAA7K,EAAA6K,GACAlK,EAAAA,EAAA1O,QAGAkO,EAAAyK,EAAAC,EAAA,CAUA,IATA1K,EAAA,GACA0K,EAAAD,EACA/X,EAAA+N,IAEAT,GAAAA,EACAtN,EAAA8N,GAGA9N,EAAA8T,UACAxG,IAAAtN,EAAAsF,KAAA,IACAtF,EAAA8T,UAUA,KAPAxG,EAAAQ,EAAAlP,SACAiP,EAAAE,EAAAnP,QAGA,IAAAoB,EAAA+N,EAAAA,EAAAD,EAAAA,EAAA9N,EAAA6N,EAAAP,GAGAA,EAAA,EAAAO,GACAP,GAAAQ,IAAAD,GAAAC,EAAAD,GAAAE,EAAAF,GAAAP,GAAAT,EAAA,EACAiB,EAAAD,GAAAhB,IAAAiB,EAAAD,GAAA,EAAAC,EAAAD,GAAAhB,EAUA,OAPAS,IACAQ,EAAA,CAAAR,GAAA2G,OAAAnG,KACAkK,GAKAzG,EAAA3D,EAAAE,EAAAkK,IAmBA1I,EAAAoJ,UAAApJ,EAAAkC,GAAA,SAAAA,EAAAP,GACA,IAAA1U,EAAA6Q,EAAA3N,EACAkO,EAAA1R,KAEA,GAAA,MAAAuV,GAAAA,MAAAA,EAKA,OAJAxD,EAAAwD,EAAA,EAAAtE,GACA,MAAA+D,EAAAA,EAAAvB,EACA1B,EAAAiD,EAAA,EAAA,GAEAJ,EAAA,IAAAvE,EAAAqB,GAAA6D,EAAAP,GAGA,KAAA1U,EAAAoR,EAAApR,GAAA,OAAA,KAIA,GAFA6Q,GADA3N,EAAAlD,EAAAqC,OAAA,GACAkO,EAAA,EAEArN,EAAAlD,EAAAkD,GAAA,CAGA,KAAAA,EAAA,IAAA,EAAAA,GAAA,GAAA2N,KAGA,IAAA3N,EAAAlD,EAAA,GAAAkD,GAAA,GAAAA,GAAA,GAAA2N,MAKA,OAFAoE,GAAA7D,EAAAhR,EAAA,EAAAyQ,IAAAA,EAAAO,EAAAhR,EAAA,GAEAyQ,GAYAkC,EAAAqJ,UAAA,SAAA1Q,GAEA,OADA+F,EAAA/F,GAAA8E,EAAAA,GACA9Q,KAAA4a,MAAA,KAAA5O,IAeAqH,EAAAsJ,WAAAtJ,EAAAuJ,KAAA,WACA,IAAAvH,EAAAlE,EAAA1F,EAAAoR,EAAA9Y,EACA2N,EAAA1R,KACAM,EAAAoR,EAAApR,EACAgR,EAAAI,EAAAJ,EACA5Q,EAAAgR,EAAAhR,EACA0W,EAAA5D,EAAA,EACA6G,EAAA,IAAAhK,EAAA,OAGA,GAAA,IAAAiB,IAAAhR,IAAAA,EAAA,GACA,OAAA,IAAA+P,GAAAiB,GAAAA,EAAA,KAAAhR,GAAAA,EAAA,IAAAoZ,IAAApZ,EAAAoR,EAAA,EAAA,GA8BA,GAtBA,IAJAJ,EAAAjG,KAAAuR,MAAAlL,KAIAJ,GAAA,EAAA,KACAH,EAAAC,EAAA9Q,IACAqC,OAAAjC,GAAA,GAAA,IAAAyQ,GAAA,KACAG,EAAAjG,KAAAuR,KAAAzL,GACAzQ,EAAAwQ,GAAAxQ,EAAA,GAAA,IAAAA,EAAA,GAAAA,EAAA,GASA+K,EAAA,IAAA4E,EANAc,EADAG,GAAA,EAAA,EACA,KAAA5Q,GAEAyQ,EAAAG,EAAAc,iBACAjP,MAAA,EAAAgO,EAAA3H,QAAA,KAAA,GAAA9I,IAKA+K,EAAA,IAAA4E,EAAAiB,EAAA,IAOA7F,EAAAnL,EAAA,GAMA,KAJAgR,GADA5Q,EAAA+K,EAAA/K,GACA0W,GACA,IAAA9F,EAAA,KAOA,GAHAvN,EAAA0H,EACAA,EAAA4O,EAAAO,MAAA7W,EAAA8X,KAAAjJ,EAAAlB,EAAA3N,EAAAqT,EAAA,KAEAhG,EAAArN,EAAAzD,GAAA6C,MAAA,EAAAmO,MAAAH,EACAC,EAAA3F,EAAAnL,IAAA6C,MAAA,EAAAmO,GAAA,CAWA,GANA7F,EAAA/K,EAAAA,KAAA4Q,EAMA,SALAH,EAAAA,EAAAhO,MAAAmO,EAAA,EAAAA,EAAA,MAKAuL,GAAA,QAAA1L,GAgBA,EAIAA,KAAAA,EAAAhO,MAAA,IAAA,KAAAgO,EAAAmB,OAAA,MAGAsC,EAAAnJ,EAAAA,EAAA/K,EAAA8S,EAAA,EAAA,GACA6B,GAAA5J,EAAAmP,MAAAnP,GAAAsP,GAAArJ,IAGA,MAvBA,IAAAmL,IACAjI,EAAA7Q,EAAAA,EAAArD,EAAA8S,EAAA,EAAA,GAEAzP,EAAA6W,MAAA7W,GAAAgX,GAAArJ,IAAA,CACAjG,EAAA1H,EACA,MAIAqT,GAAA,EACA9F,GAAA,EACAuL,EAAA,EAkBA,OAAAjI,EAAAnJ,EAAAA,EAAA/K,EAAA8S,EAAA,EAAAC,EAAA4B,IAaAhC,EAAAjB,cAAA,SAAAgF,EAAApC,GAKA,OAJA,MAAAoC,IACArF,EAAAqF,EAAA,EAAAnG,GACAmG,KAEArC,EAAA/U,KAAAoX,EAAApC,EAAA,IAgBA3B,EAAAyJ,QAAA,SAAA1F,EAAApC,GAKA,OAJA,MAAAoC,IACArF,EAAAqF,EAAA,EAAAnG,GACAmG,EAAAA,EAAApX,KAAAU,EAAA,GAEAqU,EAAA/U,KAAAoX,EAAApC,IAuBA3B,EAAA0J,SAAA,SAAA3F,EAAApC,GACA,IAAA3C,EAAArS,KAAA8c,QAAA1F,EAAApC,GAEA,GAAAhV,KAAAM,EAAA,CACA,IAAAoC,EACAkV,EAAAvF,EAAA2K,MAAA,KACAC,GAAAhJ,EAAAG,UACA8I,GAAAjJ,EAAAI,mBACAF,EAAAF,EAAAE,eACAgJ,EAAAvF,EAAA,GACAwF,EAAAxF,EAAA,GACAyF,EAAArd,KAAAsR,EAAA,EACAgM,EAAAD,EAAAF,EAAAha,MAAA,GAAAga,EACA3K,EAAA8K,EAAA3a,OAIA,GAFAua,IAAAxa,EAAAua,EAAAA,EAAAC,EAAAA,EAAAxa,EAAA8P,GAAA9P,GAEAua,EAAA,GAAAzK,EAAA,EAAA,CAIA,IAHA9P,EAAA8P,EAAAyK,GAAAA,EACAE,EAAAG,EAAA9b,OAAA,EAAAkB,GAEAA,EAAA8P,EAAA9P,GAAAua,EACAE,GAAAhJ,EAAAmJ,EAAA9b,OAAAkB,EAAAua,GAGAC,EAAA,IAAAC,GAAAhJ,EAAAmJ,EAAAna,MAAAT,IACA2a,IAAAF,EAAA,IAAAA,GAGA9K,EAAA+K,EACAD,EAAAlJ,EAAAC,mBAAAgJ,GAAAjJ,EAAAM,mBACA6I,EAAAvY,QAAA,IAAA0Y,OAAA,OAAAL,EAAA,OAAA,KACA,KAAAjJ,EAAAK,wBACA8I,GACAD,EAGA,OAAA9K,GAeAgB,EAAAmK,WAAA,SAAAC,GACA,IAAA7F,EAAAhU,EAAA8Z,EAAAC,EAAAC,EAAAld,EAAAmd,EAAA1M,EAAA2M,EAAAC,EAAA/E,EAAA1H,EACAI,EAAA1R,KACA6R,EAAAH,EAAApR,EAEA,GAAA,MAAAmd,MACAtM,EAAA,IAAAd,EAAAoN,IAGA/C,cAAAvJ,EAAA7Q,GAAA,IAAA6Q,EAAAG,IAAAH,EAAA6F,GAAAzD,IACA,MAAAhI,MACAmF,EAAA,aACAS,EAAAuJ,YAAA,iBAAA,oBAAA+C,GAIA,IAAA5L,EAAA,OAAAH,EAAA9O,WAoBA,IAlBAgB,EAAA,IAAAyM,EAAAkD,GACAwK,EAAAL,EAAA,IAAArN,EAAAkD,GACAoK,EAAAG,EAAA,IAAAzN,EAAAkD,GACAjC,EAAAF,EAAAS,GAIAnR,EAAAkD,EAAAlD,EAAA4Q,EAAA3O,OAAA+O,EAAAhR,EAAA,EACAkD,EAAAtD,EAAA,GAAAyQ,GAAA8M,EAAAnd,EAAAmQ,GAAA,EAAAA,EAAAgN,EAAAA,GACAJ,GAAAA,GAAAtM,EAAA4I,WAAAnW,GAAA,EAAAlD,EAAA,EAAAkD,EAAAma,EAAA5M,EAEA0M,EAAAhK,EACAA,EAAA,EAAA,EACA1C,EAAA,IAAAd,EAAAiB,GAGAwM,EAAAxd,EAAA,GAAA,EAGA0Y,EAAApG,EAAAzB,EAAAvN,EAAA,EAAA,GAEA,IADAga,EAAAF,EAAA7B,KAAA7C,EAAA4B,MAAA+C,KACA5D,WAAA0D,IACAC,EAAAC,EACAA,EAAAC,EACAG,EAAAD,EAAAjC,KAAA7C,EAAA4B,MAAAgD,EAAAG,IACAD,EAAAF,EACAha,EAAAuN,EAAAwK,MAAA3C,EAAA4B,MAAAgD,EAAAha,IACAuN,EAAAyM,EAgBA,OAbAA,EAAAhL,EAAA6K,EAAA9B,MAAA+B,GAAAC,EAAA,EAAA,GACAG,EAAAA,EAAAjC,KAAA+B,EAAAhD,MAAAmD,IACAL,EAAAA,EAAA7B,KAAA+B,EAAAhD,MAAA+C,IACAG,EAAAxM,EAAAyM,EAAAzM,EAAAI,EAAAJ,EAIAsG,EAAAhF,EAAAmL,EAAAJ,EAHAjd,GAAA,EAGA+S,GAAAkI,MAAAjK,GAAAoI,MAAAC,WACAnH,EAAAkL,EAAAJ,EAAAhd,EAAA+S,GAAAkI,MAAAjK,GAAAoI,OAAA,EACA,CAAAiE,EAAAnb,WAAA+a,EAAA/a,YACA,CAAAkb,EAAAlb,WAAA8a,EAAA9a,YAEAiR,EAAAgK,EACAjG,GAOAvE,EAAA2K,SAAA,WACA,OAAAhe,MAeAqT,EAAA4K,YAAA,SAAA1I,EAAAP,GAEA,OADA,MAAAO,GAAAxD,EAAAwD,EAAA,EAAAtE,GACA8D,EAAA/U,KAAAuV,EAAAP,EAAA,IAeA3B,EAAAzQ,SAAA,SAAAgP,GACA,IAAAS,EACAlB,EAAAnR,KACAsR,EAAAH,EAAAG,EACA5Q,EAAAyQ,EAAAzQ,EA0BA,OAvBA,OAAAA,EAEA4Q,GACAe,EAAA,WACAf,EAAA,IAAAe,EAAA,IAAAA,IAEAA,EAAA,OAGAA,EAAAjB,EAAAD,EAAA7Q,GAEA,MAAAsR,EACAS,EAAA3R,GAAAgT,GAAAhT,GAAAiT,EACAvB,EAAAC,EAAA3R,GACA6R,EAAAF,EAAA3R,EAAA,MAEAqR,EAAAH,EAAA,EAAA4C,EAAA7R,OAAA,QACA0P,EAAAQ,EAAAN,EAAAF,EAAA3R,EAAA,KAAA,GAAAkR,EAAAN,GAAA,IAGAA,EAAA,GAAAH,EAAA7Q,EAAA,KAAA+R,EAAA,IAAAA,IAGAA,GAQAgB,EAAAC,QAAAD,EAAA6K,OAAA,WACA,IAAA7L,EACAlB,EAAAnR,KACAU,EAAAyQ,EAAAzQ,EAEA,OAAA,OAAAA,EAAAyQ,EAAAvO,YAEAyP,EAAAjB,EAAAD,EAAA7Q,GAEA+R,EAAA3R,GAAAgT,GAAAhT,GAAAiT,EACAvB,EAAAC,EAAA3R,GACA6R,EAAAF,EAAA3R,EAAA,KAEAyQ,EAAAG,EAAA,EAAA,IAAAe,EAAAA,IAIAgB,EAAAyD,cAAA,EAEA,MAAAnE,GAAAtC,EAAApI,IAAA0K,GAEAtC,EAuIAqC,IACA,QAAArC,EAAAA,UAAAA,EACAD,EAAAC,UAAAA,EAluFA,CAmuFA/Q,MAAAC,OACA,MAAA8Q,UAAA/Q,MAAAC,MAAA8Q,UACAA,UAAAgG,OAAA,CAAA7C,eAAA,KCruFA,MAAA2K,YAKAxe,eAAAye,GACA,OAAAC,OAAA3D,UAAA0D,IACAA,GAAA,GAAAA,GAAAD,YAAAG,UAOA3e,gBAAAye,GACA,OAAAC,OAAA3D,UAAA0D,IACAA,GAAA,GAAAA,GAAAD,YAAAI,WAOA5e,gBAAAye,GACA,OAAAC,OAAA3D,UAAA0D,IACAA,GAAA,GAAAA,GAAAD,YAAAK,WAOA7e,gBAAAye,GACA,OAAAC,OAAA3D,UAAA0D,IACAA,GAAA,GAAAA,GAAAD,YAAAM,WAOA9e,iBAAAye,GACA,OAAAA,EAAA1D,aAAA0D,EAAAhD,IAAA,IAAAgD,EAAA7C,IAAA4C,YAAAO,aAMA/e,sBACA,OAAA0L,KAAAoF,MAAApF,KAAA8L,UAAAgH,YAAAK,WAAA,IAMA7e,sBACA,OAAA0L,KAAAoF,MAAApF,KAAA8L,UAAAgH,YAAAM,WAAA,IAOA9e,kBAAAgf,GACA,OAAAjb,SAAAib,EAAA,IAIAR,YAAAG,UAAA,IACAH,YAAAI,WAAA,MACAJ,YAAAK,WAAA,WACAL,YAAAM,WAAAJ,OAAAvN,iBACAqN,YAAAO,YAAA,IAAArO,UAAA,mCAAA,IAEA/Q,MAAAQ,SAAAqe,aC1EA,MAAAxT,YAKAhL,eAAA6O,GACA,MACAoQ,EAAAjU,YAAAkU,aAAArQ,GAEA,IAAAsQ,EAAA,GACA,IAAA,IAAApc,EAAA,EAAAA,EAAAkc,EAAAjc,OAAAD,GAJA,KAKAoc,GAAAC,OAAAC,aAAArd,MAAA,KAAAid,EAAAK,SAAAvc,EAAAA,EALA,OAOA,OAAAoc,EAOAnf,iBAAAuf,GACA,MAAAN,EAAA,IAAAjR,WAAAuR,EAAAvc,QACA,IAAA,IAAAD,EAAA,EAAAA,EAAAwc,EAAAvc,SAAAD,EACAkc,EAAAlc,GAAAwc,EAAA1N,WAAA9O,GAEA,OAAAkc,EAGAjf,6BAAA6O,GACA,GAAA,oBAAA2Q,YAAA,MAAA,IAAA5T,MAAA,6BACA,GAAA,OAAAZ,YAAAyU,qBAAA,MAAA,IAAA7T,MAAA,4CACA,QAAAlI,IAAAsH,YAAAyU,qBACA,IACAzU,YAAAyU,qBAAA,IAAAD,YAAA,eACA,MAAAze,GAEA,MADAiK,YAAAyU,qBAAA,KACA,IAAA7T,MAAA,4CAGA,MAAA8T,EAAA1U,YAAAkU,aAAArQ,GACA,OAAA7D,YAAAyU,qBAAAE,OAAAD,GACAxa,QAAA,UAAA,KACAA,QAAA,UAAA,KACAA,QAAA,UAAA,KACAA,QAAA,UAAA,KACAA,QAAA,UAAA,KACAA,QAAA,UAAA,KACAA,QAAA,UAAA,KACAA,QAAA,UAAA,KAGAlF,wBAAA4f,GACA,OAAA5U,YAAA6U,eAAAD,GAAA,GAAA,IAAA5U,YAAA6U,eAAAD,GAAA,GAAA,IAAA5U,YAAA6U,eAAAD,GAAA,EAAA,IAAA5U,YAAA6U,eAAA,GAAAD,GAGA5f,0BAAA8f,EAAAta,EAAAua,GACA,IAAAC,EACA,MAAAC,EAAA,GACA,IAAA,IAAAld,EAAAyC,EAAAzC,EAAAgd,EAAAhd,GAAA,EACAid,GAAAF,EAAA/c,IAAA,GAAA,WAAA+c,EAAA/c,EAAA,IAAA,EAAA,QAAA,IAAA+c,EAAA/c,EAAA,IACAkd,EAAAvW,KAAAsB,YAAAkV,iBAAAF,IAEA,OAAAC,EAAAE,KAAA,IAGAngB,4BAAA8f,GACA,IAAAE,EACA,MAAAnN,EAAAiN,EAAA9c,OACAod,EAAAvN,EAAA,EACA,IAAAoN,EAAA,GACA,MAAAI,EAAA,GAIA,IAAA,IAAAtd,EAAA,EAAAud,EAAAzN,EAAAuN,EAAArd,EAAAud,EAAAvd,GAHA,MAIAsd,EAAA3W,KAAAsB,YAAAuV,mBAAAT,EAAA/c,EAAAA,EAJA,MAIAud,EAAAA,EAAAvd,EAJA,QAuBA,OAfA,IAAAqd,GACAJ,EAAAF,EAAAjN,EAAA,GACAoN,GAAAjV,YAAA6U,eAAAG,GAAA,GACAC,GAAAjV,YAAA6U,eAAAG,GAAA,EAAA,IACAC,GAAA,MACA,IAAAG,IACAJ,GAAAF,EAAAjN,EAAA,IAAA,GAAAiN,EAAAjN,EAAA,GACAoN,GAAAjV,YAAA6U,eAAAG,GAAA,IACAC,GAAAjV,YAAA6U,eAAAG,GAAA,EAAA,IACAC,GAAAjV,YAAA6U,eAAAG,GAAA,EAAA,IACAC,GAAA,KAGAI,EAAA3W,KAAAuW,GAEAI,EAAAF,KAAA,IAOAngB,gBAAA6O,GACA,GAAAnB,cAAAI,WACA,OAAA0S,OAAAC,KAAA5R,GAAA5L,SAAA,UACA,GAAA,oBAAAuc,aAAA,OAAAxU,YAAAyU,qBACA,IACA,OAAAiB,KAAA1V,YAAA2V,sBAAA9R,IACA,MAAA9N,IAKA,OAAAiK,YAAA4V,qBAAA5V,YAAAkU,aAAArQ,IAQA7O,kBAAA6gB,EAAA7d,GACA,MAAAiV,EAAA,IAAAjK,WAAA8S,KAAAD,GAAAxD,MAAA,IAAA0D,IAAApgB,GAAAA,EAAAkR,WAAA,KACA,QAAAnO,IAAAV,GAAAiV,EAAAjV,SAAAA,EAAA,MAAA,IAAA4I,MAAA,iDACA,OAAA,IAAAnB,aAAAwN,GAOAjY,mBAAA6O,GACA,OAAA7D,YAAAgW,SAAAnS,GAAA3J,QAAA,MAAA,KAAAA,QAAA,MAAA,KAAAA,QAAA,KAAA,KAQAlF,qBAAA6gB,EAAA7d,GACA,OAAAgI,YAAAiW,WAAAJ,EAAA3b,QAAA,KAAA,KAAAA,QAAA,KAAA,KAAAA,QAAA,MAAA,KAAAlC,GAQAhD,gBAAAif,EAAAnK,EAAA9J,YAAAkW,gBAAAC,SACA,IAAArW,EAAAsW,EAAAre,EAAA4G,EAAA,EAAAgP,EAAA,EAAAhT,EAAA,GAEA,IAAA5C,EAAA,EAAAA,EAAAkc,EAAAjc,OAAAD,IAGA4C,GAAAmP,EAAA,IADAsM,EAAAzI,GADA7N,EAAAmU,EAAAlc,KACA4G,IAGAA,EAAA,IAGAhE,GAAAmP,EAAA,IADAsM,EAAAtW,IADAnB,GAAA,MAMAgP,EAAA7N,IADAnB,EAAA,EAAAA,GAEAA,EAAA,EAAAA,EAOA,IAJA,IAAAA,IACAhE,GAAAmP,EAAA,GAAA6D,IAGAhT,EAAA3C,OAAA,GAAA,GAAA,KAAA8R,EAAA9R,QACA2C,GAAAmP,EAAA,IAGA,OAAAnP,EAQA3F,kBAAAqhB,EAAAvM,EAAA9J,YAAAkW,gBAAAC,SACA,MAAAG,EAAA,GACAxM,EAAAyM,cAAAlE,MAAA,IAAAmE,QAAA,CAAA7gB,EAAAoC,KACApC,KAAA2gB,IAAAA,EAAA3gB,GAAAoC,KAGA,IAAAqe,EAAAzX,EAAA,EAAAgP,EAAA,EAAAsG,EAAA,GAyBA,OAxBAoC,EAAAE,cAAAlE,MAAA,IAAAmE,QAAAC,IAEA,KAAA3M,EAAA9R,QAAAye,IAAA3M,EAAA,MAEAsM,EAAA,IAAAE,EAAAG,IAEA9X,GAAA,GACA,EACAgP,GAAAyI,GAAAzX,EACAA,EAAA,GACAsV,EAAAvV,KAAAiP,EAAAyI,IAAAzX,GAEAgP,EAAAyI,IADAzX,GAAA,GACA,MAEAsV,EAAAvV,KAAAiP,EAAAyI,GACAzX,EAAA,EACAgP,EAAA,MAIA,IAAAhP,GAAA,IAAAgP,GACAsG,EAAAvV,KAAAiP,GAGA,IAAA3K,WAAAiR,GAOAjf,aAAA6O,GACA,IAAA6S,EAAA,GACA,IAAA,IAAA3e,EAAA,EAAAA,EAAA8L,EAAA7L,OAAAD,IAAA,CACA,MAAA4e,EAAA9S,EAAA9L,GACA2e,GAAA1W,YAAA4W,aAAAD,IAAA,GACAD,GAAA1W,YAAA4W,aAAA,GAAAD,GAEA,OAAAD,EAQA1hB,eAAA0hB,EAAA1e,GAEA,GADA0e,EAAAA,EAAAG,QACAC,YAAAC,WAAAL,EAAA1e,GAAA,MAAA,IAAA4I,MAAA,oDACA,OAAA,IAAAnB,aAAA,IAAAuD,YAAA0T,EAAAM,MAAA,UAAA,IAAAjB,IAAAjW,GAAA/G,SAAA+G,EAAA,OAOA9K,gBAAA6O,GACA,IAAAmQ,EAAA,GACA,IAAA,IAAAjc,EAAA,EAAAA,EAAA8L,EAAA7L,OAAAD,IAAA,CACA,MAAA4e,EAAA9S,EAAA9L,GACAic,GAAA8C,YAAAG,KAAAN,EAAA1e,SAAA,GAAA,IAAA,GAEA,OAAA+b,EAUAhf,wBAAA0S,GACA,MAAA3E,EAAA,GACA,IAAA4I,EAAA,EACA,IAAA,IAAA5T,EAAA,EAAAA,EAAA2P,EAAA1P,OAAAD,IAAA,CACA,IAAApC,EAAA+R,EAAAb,WAAA9O,GACApC,EAAA,IACAoN,EAAA4I,KAAAhW,EACAA,EAAA,MACAoN,EAAA4I,KAAAhW,GAAA,EAAA,IACAoN,EAAA4I,KAAA,GAAAhW,EAAA,KAEA,QAAA,MAAAA,IAAAoC,EAAA,EAAA2P,EAAA1P,QACA,QAAA,MAAA0P,EAAAb,WAAA9O,EAAA,KAEApC,EAAA,QAAA,KAAAA,IAAA,KAAA,KAAA+R,EAAAb,aAAA9O,IACAgL,EAAA4I,KAAAhW,GAAA,GAAA,IACAoN,EAAA4I,KAAAhW,GAAA,GAAA,GAAA,IACAoN,EAAA4I,KAAAhW,GAAA,EAAA,GAAA,IACAoN,EAAA4I,KAAA,GAAAhW,EAAA,MAEAoN,EAAA4I,KAAAhW,GAAA,GAAA,IACAoN,EAAA4I,KAAAhW,GAAA,EAAA,GAAA,IACAoN,EAAA4I,KAAA,GAAAhW,EAAA,KAGA,OAAA,IAAAqN,WAAAD,GAQA/N,wBAAA0S,GACA,GAAA,oBAAAwP,YAAA,MAAA,IAAAtW,MAAA,6BACA,GAAA,OAAAZ,YAAAmX,cAAA,MAAA,IAAAvW,MAAA,qCACA,QAAAlI,IAAAsH,YAAAmX,cACA,IACAnX,YAAAmX,cAAA,IAAAD,YACA,MAAAnhB,GAEA,MADAiK,YAAAmX,cAAA,KACA,IAAAvW,MAAA,qCAGA,OAAAZ,YAAAmX,cAAAC,OAAA1P,GAOA1S,gBAAA0S,GACA,GAAAhF,cAAAI,WACA,OAAA0S,OAAAC,KAAA/N,GACA,GAAA,oBAAAwP,aAAA,OAAAlX,YAAAmX,cACA,IACA,OAAAnX,YAAAqX,iBAAA3P,GACA,MAAA3R,IAIA,OAAAiK,YAAAsX,iBAAA5P,GAQA1S,eAAAuiB,EAAAvf,GACA,GAAA,KAAAuf,EAAA,OAAA9X,aAAA+X,MACA,IAAAD,EAAA,MAAA,IAAA3W,MAAA,yBACA,GAAA2W,aAAAvU,WAAA,OAAA,IAAAvD,aAAA8X,GACA,IACA,OAAAvX,YAAAyX,QAAAF,EAAAvf,GACA,MAAAjC,IAGA,IACA,OAAAiK,YAAAiW,WAAAsB,EAAAvf,GACA,MAAAjC,IAGA,MAAA,IAAA6K,MAAA,yBAUA5L,yBAAA0R,EAAAO,GACA,MAAAtR,EAAA,IAAA+Q,EAAA,YAAAA,EAAA1O,OAAAiP,EAAAjP,QAGA,OAFArC,EAAA2H,IAAAoJ,EAAA,GACA/Q,EAAA2H,IAAA2J,EAAAP,EAAA1O,QACArC,EAQAX,cAAA0R,EAAAO,GACA,MAAAyQ,EAAA1X,YAAAkU,aAAAxN,GACAiR,EAAA3X,YAAAkU,aAAAjN,GACA,GAAAyQ,EAAA1f,SAAA2f,EAAA3f,OAAA,OAAA,EACA,IAAA,IAAAD,EAAA,EAAAA,EAAA2f,EAAA1f,OAAAD,IACA,GAAA2f,EAAA3f,KAAA4f,EAAA5f,GAAA,OAAA,EAEA,OAAA,EAQA/C,eAAA0R,EAAAO,GACA,GAAAP,EAAA1O,OAAAiP,EAAAjP,OAAA,OAAA,EACA,GAAA0O,EAAA1O,OAAAiP,EAAAjP,OAAA,OAAA,EACA,IAAA,IAAAD,EAAA,EAAAA,EAAA2O,EAAA1O,OAAAD,IAAA,CACA,GAAA2O,EAAA3O,GAAAkP,EAAAlP,GAAA,OAAA,EACA,GAAA2O,EAAA3O,GAAAkP,EAAAlP,GAAA,OAAA,EAEA,OAAA,EAQA/C,WAAA0R,EAAAO,GACA,MAAAtM,EAAA,IAAAqI,WAAA0D,EAAAjF,YACA,IAAA,IAAA1J,EAAA,EAAAA,EAAA2O,EAAAjF,aAAA1J,EACA4C,EAAA5C,GAAA2O,EAAA3O,GAAAkP,EAAAlP,GAEA,OAAA4C,EAQA3F,oBAAA4iB,GACA,GAAAA,aAAA5U,WACA,OAAA4U,EACA,GAAAA,aAAAC,YACA,OAAA,IAAA7U,WAAA4U,GACA,GAAAA,EAAA/T,kBAAAgU,YACA,OAAA,IAAA7U,WAAA4U,EAAA/T,QAEA,MAAA,IAAAjD,MAAA,sCASA5L,gBAAAif,EAAAnK,EAAA9J,YAAA8X,iBACA,IAEA1W,EAFAgW,EAAA,GACAW,EAAA,GACAhgB,EAAA,EAGA,KAAAA,EAAAkc,EAAAjc,SACAic,EAAAlc,GADAA,IAIAggB,GAAAjO,EAAA,GAIA,KAAA/R,EAAAkc,EAAAjc,OAAAD,IAAA,CACA,IAAA4V,EAAAsG,EAAAlc,GAEA,IADAqJ,EAAA,EACAA,KAAAgW,GAAAzJ,GAAA,CACA,IAAAnH,EAAA4Q,EAAAhW,IAAAgW,EAAAhW,IAAA,GAAAuM,EAAAA,EACAA,EAAAnH,EAAA,GAAA,EACA4Q,EAAAhW,GAAAoF,EAAA,GACApF,KAIA,KAAAA,KACA2W,GAAAjO,EAAAsN,EAAAhW,IAGA,OAAA2W,EAQA/iB,kBAAAgjB,EAAAlO,EAAA9J,YAAA8X,iBACA,IAEA1W,EAFA6W,EAAA,GACAtD,EAAA,GACA5c,EAAA,EAEA,KAAAA,EAAAigB,EAAAhgB,SACA8R,EAAAjL,QAAAmZ,EAAAjgB,IADAA,IAIAkgB,EAAAvZ,KAAA,GAIA,KAAA3G,EAAAigB,EAAAhgB,OAAAD,IAAA,CACA,IAAA4V,EAAA7D,EAAAjL,QAAAmZ,EAAAjgB,IACA,GAAA4V,EAAA,EAAA,MAAA,GAEA,IADAvM,EAAA,EACAA,KAAAuT,GAAAhH,GAAA,CACA,IAAAnH,EAAAmO,EAAAvT,GAAA,GAAAuT,EAAAvT,GAAAuM,EAAAA,EACAA,EAAAnH,GAAA,EACAmO,EAAAvT,GAAAoF,EAAA,IACApF,KAIA,KAAAA,KACA6W,EAAAvZ,KAAAiW,EAAAvT,IAGA,OAAA,IAAA4B,WAAAiV,GAUAjjB,qBAAAif,EAAAiE,EAAA,IAAAC,EAAArO,EAAA9J,YAAA8X,iBACA,IAAA9V,EACAA,EAAA,IAAAvC,aAAA0Y,EAAA,CAAA,IAAAD,KAAAjE,EAAA,IAAAkE,GACA,CAAA,IAAAD,KAAAjE,IACA,MAAAmE,EAAA1Y,KAAA2Y,cAAA3Y,KAAA2Y,cAAArW,IAAAsS,SAAA,EAAA,GACAzQ,EAAA,IAAApE,aAAA,IAAAuC,KAAAoW,IACA,OAAApY,YAAAsY,SAAAzU,EAAAiG,GASA9U,uBAAAgjB,EAAAO,GAAA,EAAAzO,EAAA9J,YAAA8X,iBACA,MAAA7C,EAAAjV,YAAAwY,WAAAR,EAAAlO,GAEAiL,EAAAwD,GAAA,GAAA,EACA,OAAA,IAAAvV,WAAAiS,EAAAzc,MAAA,EAAAuc,KAGA/U,YAAAyY,gBAAA,mEACAzY,YAAAkW,gBAAA,CACAwC,QAAA,oCACAC,YAAA,oCACAxC,QAAA,oCAEAnW,YAAA4W,aAAA,mBACA5W,YAAA6U,eAAA,GACA,IAAA,IAAA9c,EAAA,EAAA8P,EAAA7H,YAAAyY,gBAAAzgB,OAAAD,EAAA8P,IAAA9P,EACAiI,YAAA6U,eAAA9c,GAAAiI,YAAAyY,gBAAA1gB,GAEAiI,YAAA8X,gBAAA,6DAEAnjB,MAAAQ,SAAA6K,aC1hBA,MAAAP,qBAAAuD,WAIAhO,YAAA4jB,GACApc,MAAAoc,GACAvjB,KAAAwjB,MAAA,IAAAC,SAAAzjB,KAAAwO,QACAxO,KAAA0jB,SAAA,EACA1jB,KAAA2jB,UAAA,EAQAhkB,SAAAwF,EAAAua,GACA,OAAAkE,WAAA3E,SAAAjf,KAAAmF,EAAAua,GAIAmE,cACA,OAAA7jB,KAAA0jB,SAIAG,YAAAC,GACA,GAAAA,EAAA,GAAAA,EAAA9jB,KAAAoM,WAAA,wBAAA0X,IACA9jB,KAAA0jB,SAAAI,EAIAC,eACA,OAAA/jB,KAAA2jB,UAIAI,aAAAD,GACA,GAAAA,EAAA,GAAAA,EAAA9jB,KAAAoM,WAAA,yBAAA0X,IACA9jB,KAAA2jB,UAAAG,EAOAnkB,QACAK,KAAA0jB,SAAA,EACA1jB,KAAA2jB,UAAA,EAOAhkB,KAAAgD,GACA,MAAAmhB,EAAA9jB,KAAAif,SAAAjf,KAAA0jB,SAAA1jB,KAAA0jB,SAAA/gB,GAEA,OADA3C,KAAA0jB,UAAA/gB,EACA,IAAAgL,WAAAmW,GAMAnkB,MAAAqkB,GACAhkB,KAAAiI,IAAA+b,EAAAhkB,KAAA2jB,WACA3jB,KAAA2jB,WAAAK,EAAA5X,WAMAzM,YACA,OAAAK,KAAAwjB,MAAAS,SAAAjkB,KAAA0jB,YAMA/jB,WAAAmkB,GACA9jB,KAAAwjB,MAAAU,SAAAlkB,KAAA2jB,YAAAG,GAMAnkB,aACA,MAAAmkB,EAAA9jB,KAAAwjB,MAAAW,UAAAnkB,KAAA0jB,UAEA,OADA1jB,KAAA0jB,UAAA,EACAI,EAMAnkB,YAAAmkB,GACA9jB,KAAAwjB,MAAAY,UAAApkB,KAAA2jB,UAAAG,GACA9jB,KAAA2jB,WAAA,EAMAhkB,aACA,MAAAmkB,EAAA9jB,KAAAwjB,MAAAa,UAAArkB,KAAA0jB,UAEA,OADA1jB,KAAA0jB,UAAA,EACAI,EAMAnkB,YAAAmkB,GACA9jB,KAAAwjB,MAAAc,UAAAtkB,KAAA2jB,UAAAG,GACA9jB,KAAA2jB,WAAA,EAMAhkB,aACA,MAAAmkB,EAAA9jB,KAAAwjB,MAAAa,UAAArkB,KAAA0jB,UAAArY,KAAAC,IAAA,EAAA,IAAAtL,KAAAwjB,MAAAa,UAAArkB,KAAA0jB,SAAA,GACA,IAAAvF,YAAAoG,SAAAT,GAAA,MAAA,IAAAvY,MAAA,mBAEA,OADAvL,KAAA0jB,UAAA,EACAI,EAMAnkB,YAAAmkB,GACA,IAAA3F,YAAAoG,SAAAT,GAAA,MAAA,IAAAvY,MAAA,mBACAvL,KAAAwjB,MAAAc,UAAAtkB,KAAA2jB,UAAAtY,KAAAoF,MAAAqT,EAAAzY,KAAAC,IAAA,EAAA,MACAtL,KAAAwjB,MAAAc,UAAAtkB,KAAA2jB,UAAA,EAAAG,GACA9jB,KAAA2jB,WAAA,EAMAhkB,cACA,MAAA6kB,EAAA,IAAAnU,UAAA,4BAAA,IACAoU,EAAA,IAAApU,UAAA,oBAAA,IACAqU,EAAA,IAAArU,UAAA,YAAA,IACAsU,EAAA3kB,KAAAwjB,MAAAa,UAAArkB,KAAA0jB,UACAkB,EAAA5kB,KAAAwjB,MAAAa,UAAArkB,KAAA0jB,SAAA,GACAmB,EAAA7kB,KAAAwjB,MAAAa,UAAArkB,KAAA0jB,SAAA,GACAoB,EAAA9kB,KAAAwjB,MAAAa,UAAArkB,KAAA0jB,SAAA,IACAI,EAAAU,EAAA5J,MAAA+J,GAAA9I,KAAA4I,EAAA7J,MAAAgK,IAAA/I,KAAA6I,EAAA9J,MAAAiK,IAAAhJ,KAAAiJ,GACA,IAAA3G,YAAA4G,UAAAjB,GAAA,MAAA,IAAAvY,MAAA,mBAEA,OADAvL,KAAA0jB,UAAA,GACAI,EAMAnkB,aAAAmkB,GACA,IAAA3F,YAAA4G,UAAAjB,GAAA,MAAA,IAAAvY,MAAA,mBACA,MAAAiZ,EAAA,IAAAnU,UAAA,4BAAA,IACAoU,EAAA,IAAApU,UAAA,oBAAA,IACAqU,EAAA,IAAArU,UAAA,YAAA,IACAsU,EAAAb,EAAA3J,KAAAqK,GACAI,EAAAd,EAAAnJ,IAAA6J,GAAArK,KAAAsK,GACAI,EAAAf,EAAAnJ,IAAA8J,GAAAtK,KAAAuK,GACAI,EAAAhB,EAAAnJ,IAAA+J,GACA1kB,KAAAwjB,MAAAc,UAAAtkB,KAAA2jB,UAAAgB,EAAA3G,YACAhe,KAAAwjB,MAAAc,UAAAtkB,KAAA2jB,UAAA,EAAAiB,EAAA5G,YACAhe,KAAAwjB,MAAAc,UAAAtkB,KAAA2jB,UAAA,EAAAkB,EAAA7G,YACAhe,KAAAwjB,MAAAc,UAAAtkB,KAAA2jB,UAAA,GAAAmB,EAAA9G,YACAhe,KAAA2jB,WAAA,GAMAhkB,cACA,MAAAmkB,EAAA9jB,KAAAglB,YACA,OAAAlB,EAAA,IACAA,EACA,MAAAA,EACA9jB,KAAAilB,aACA,MAAAnB,EACA9jB,KAAAklB,aAEAllB,KAAAmlB,aAOAxlB,aAAAmkB,GACA,IAAA3F,YAAAoG,SAAAT,GAAA,MAAA,IAAAvY,MAAA,mBACAuY,EAAA,IACA9jB,KAAAolB,WAAAtB,GACAA,GAAA,OACA9jB,KAAAolB,WAAA,KACAplB,KAAAqlB,YAAAvB,IACAA,GAAA,YACA9jB,KAAAolB,WAAA,KACAplB,KAAA6L,YAAAiY,KAEA9jB,KAAAolB,WAAA,KACAplB,KAAAslB,YAAAxB,IAQAnkB,mBAAAmkB,GACA,IAAA3F,YAAAoG,SAAAT,GAAA,MAAA,IAAAvY,MAAA,mBACA,OAAAuY,EAAA,IACA,EACAA,GAAA,MACA,EACAA,GAAA,WACA,EAEA,EAOAnkB,cACA,MAAAmkB,EAAA9jB,KAAAwjB,MAAA+B,WAAAvlB,KAAA0jB,UAEA,OADA1jB,KAAA0jB,UAAA,EACAI,EAMAnkB,aAAAmkB,GACA9jB,KAAAwjB,MAAAgC,WAAAxlB,KAAA2jB,UAAAG,GACA9jB,KAAA2jB,WAAA,EAOAhkB,WAAAgD,GACA,MAAA8iB,EAAAzlB,KAAA0lB,KAAA/iB,GACA,OAAAgI,YAAAgb,QAAAF,GAOA9lB,YAAAmkB,EAAAnhB,GACA,GAAA8e,YAAAmE,YAAA9B,IAAAA,EAAAnhB,SAAAA,EAAA,MAAA,IAAA4I,MAAA,0BACA,MAAAka,EAAA9a,YAAAkb,UAAA/B,GACA9jB,KAAA4L,MAAA6Z,GAOA9lB,iBAAAgD,GACA,MAAA8iB,EAAAzlB,KAAA0lB,KAAA/iB,GACA,IAAAD,EAAA,EACA,KAAAA,EAAAC,GAAA,IAAA8iB,EAAA/iB,IAAAA,IACA,MAAAojB,EAAA,IAAAnY,WAAA8X,EAAAjX,OAAAiX,EAAAM,WAAArjB,GACA,OAAAiI,YAAAgb,QAAAG,GAOAnmB,kBAAAmkB,EAAAnhB,GACA,GAAA8e,YAAAmE,YAAA9B,IAAAA,EAAAnhB,OAAAA,EAAA,MAAA,IAAA4I,MAAA,0BACA,MAAAka,EAAA9a,YAAAkb,UAAA/B,GACA9jB,KAAA4L,MAAA6Z,GACA,MAAAO,EAAArjB,EAAA8iB,EAAArZ,WACApM,KAAA4L,MAAA,IAAA+B,WAAAqY,IAMArmB,sBACA,MAAAgD,EAAA3C,KAAAglB,YACA,GAAAhlB,KAAA0jB,SAAA/gB,EAAA3C,KAAA2C,OAAA,MAAA,IAAA4I,MAAA,oBACA,MAAAka,EAAAzlB,KAAA0lB,KAAA/iB,GACA,OAAAgI,YAAAgb,QAAAF,GAMA9lB,qBAAAmkB,GACA,GAAArC,YAAAmE,YAAA9B,KAAA3F,YAAA8H,QAAAnC,EAAAnhB,QAAA,MAAA,IAAA4I,MAAA,mBACA,MAAAka,EAAA9a,YAAAkb,UAAA/B,GACA9jB,KAAAolB,WAAAK,EAAArZ,YACApM,KAAA4L,MAAA6Z,GAOA9lB,2BAAAmkB,GACA,GAAArC,YAAAmE,YAAA9B,KAAA3F,YAAA8H,QAAAnC,EAAAnhB,QAAA,MAAA,IAAA4I,MAAA,mBACA,OAAA,EAAAuY,EAAAnhB,OAOAhD,cAAAumB,GACA,MAAAvjB,EAAAujB,EAAAC,OAAA,CAAAC,EAAAxO,IAAAwO,EAAAxO,EAAAjV,OAAA,GACA8C,EAAA,IAAA2E,aAAAzH,GACA,IAAAujB,EAAAvjB,OAAA,OAAA8C,EAEA,IAAA4gB,EAAA,EACA,IAAA,IAAAzO,KAAAsO,EACAzgB,EAAAwC,IAAA2P,EAAAyO,GACAA,GAAAzO,EAAAjV,OAGA,OAAA8C,GAGA2E,aAAA+X,MAAA,IAAA/X,aAAA,GACA9K,MAAAQ,SAAAsK,cCzUA,MAAAkc,YAQA3mB,gBAAA4mB,EAAAC,EAAAC,EAAAC,KAEApnB,MAAAQ,SAAAwmB,aCXA,MAAAK,wBAAA3iB,QAAAqE,KAAAie,cACA3mB,cACAwH,QAEAnH,KAAAoN,WAAAjG,MAAApC,KAGApF,WAAAE,SACAG,KAAAoN,WAAAhK,KAAApD,KAAAH,GACAwN,cAAAC,mBAAAC,WAAAC,kBAGA7N,gBAAAgN,EAAA6Z,EAAAC,EAAAC,GACA,MAAAhY,EAAA,IAAAf,WAAA,IACA,IAAAS,EAAAE,EACA,IACAF,EAAAH,OAAA2Y,QAAAlY,EAAA/L,QACA2L,EAAAL,OAAA2Y,QAAAja,EAAAhK,QACAsL,OAAAM,OAAAtG,IAAA0E,EAAA2B,GACA,MAAAuY,EAAA5Y,OAAA6Y,uBAAA1Y,EAAAE,EAAA3B,EAAAhK,OAAA6jB,EAAAC,EAAAC,EAAA,KACA,OAAAG,IAAAH,IACAhY,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAM,EAAA/L,SACA,CAAA+L,KAAAA,EAAAmY,MAAAA,IACA,MAAAnmB,GAEA,MADAR,IAAA4D,EAAA6iB,gBAAAjmB,GACAA,EACA,aACA2C,IAAA+K,GAAAH,OAAA8Y,MAAA3Y,QACA/K,IAAAiL,GAAAL,OAAA8Y,MAAAzY,KAKAtK,QAAAmM,oBAAAmW,YAAA,IAAAK,iBCjCA,MAAAK,wBAAAhjB,QAAAiB,KAAAqhB,cACA3mB,YAAAqF,EAAA,GACAmC,MAAAtH,GAAAmE,QAAAkB,oBAAAohB,YAAAzmB,GAAA,QAAAmF,GAEAhF,KAAAinB,gBAAA,EAEAjnB,KAAAknB,cAAA,GAEAlnB,KAAAmnB,OAAA,KAEAnnB,KAAAonB,cAAA,IAEApnB,KAAAqnB,YAAA,IAAAC,WAEAtnB,KAAAunB,cAAAC,OAAAC,iBAEAznB,KAAA0nB,cAAAC,EAAAA,EAEA3nB,KAAA4nB,WAAA,IAGA5nB,KAAA6nB,mBAAA1gB,MAAA8B,cAEAoE,cAAAI,aACAvN,IAAAwC,EAAAskB,+DAAAc,cASA9nB,KAAA+nB,UAAA,SAAAxB,EAAAC,EAAAC,EAAAC,GACA,OAAA,IAAA3e,QAAA,CAAA1B,EAAA2hB,KACAla,WAAAma,yBAAAC,MAAArB,IACA,IACA,GAAAA,IAAAH,EACArgB,GAAA,OACA,CACAkgB,EAAAxC,UAAA,EACAwC,EAAA1a,YAAAgb,GACA,MAAAnY,cAAAzC,aAAAC,oBAAAic,eAAA5B,GACAlgB,EAAA,CAAAqI,KAAAA,EAAAmY,MAAAA,KAEA,MAAAnmB,GACAsnB,EAAAtnB,KAEA6lB,EAAAC,EAAAC,EAAAC,EAAA,SASA0B,mBACA,OAAApoB,KAAAonB,cAMAgB,iBAAAC,GACAroB,KAAAonB,cAAAiB,EAMAC,mBACA,OAAAtoB,KAAA0nB,cAMAY,iBAAAA,GACAtoB,KAAA0nB,cAAAY,EAMAC,gBACA,OAAAvoB,KAAA4nB,WAMAW,cAAAA,GACAvoB,KAAA4nB,WAAAW,EAQA5oB,GAAAgH,EAAA6hB,GAAA,OAAAxoB,KAAAqnB,YAAAoB,GAAA9hB,EAAA6hB,GAMA7oB,IAAAgH,EAAAjB,GAAA1F,KAAAqnB,YAAAqB,IAAA/hB,EAAAjB,GAMA/F,yBAAAmN,EAAA6b,GAGA,GAFA3oB,KAAAmnB,OAAAra,EACA9M,KAAAunB,cAAAoB,GAAA7b,EAAA8b,MACA5oB,KAAAinB,eAQAjnB,KAAAknB,cAAA,CAAA,CAAAT,SAAA,EAAAC,SAAA,QARA,OACA1mB,KAAAiJ,gBACAjJ,KAAAknB,cAAA,GACAlnB,KAAAinB,gBAAA,EACA,IAAA,IAAAvkB,EAAA,EAAAA,EAAA1C,KAAAkJ,WAAAxG,EACA1C,KAAA6oB,eAOAlpB,OACAK,KAAAinB,gBAAA,EAGAtnB,sBAKA,IAJA0N,cAAAI,kBACAzN,KAAA6nB,mBAAAzkB,KAAApD,MAGAA,KAAAinB,gBAAAjnB,KAAAknB,cAAAvkB,OAAA3C,KAAAkJ,UACAlJ,KAAA6oB,cAIAlpB,cACA,GAAAK,KAAAknB,cAAAvkB,QAAA3C,KAAAkJ,SACA,OAGA,MAAAud,EAAA,IAAAzmB,KAAAknB,cAAAvkB,OAAA,EAAA0I,KAAA4G,IAAAtQ,MAAA,KAAA3B,KAAAknB,cAAAxG,IAAArP,GAAAA,EAAAqV,WAEAoC,EAAA,CAAArC,SAAAA,EAAAC,SADAD,EAAAzmB,KAAAonB,eAEApnB,KAAAknB,cAAA7d,KAAAyf,GACA9oB,KAAA+oB,aAAAD,GAAA1f,MAAA1I,GAAAR,IAAAQ,EAAAsmB,gBAAAtmB,IAQAf,mBAAAmpB,GACA,IAAApmB,EAAA,EACA,KAAA1C,KAAAinB,iBAAAjjB,QAAA2B,iBAAA0H,cAAAI,YAAA,IAAA/K,IAAAA,EAAA1C,KAAA0nB,eAAA,CACAhlB,IACA,MAAAoK,EAAA9M,KAAAmnB,OACA1hB,QAAAzF,KAAA+nB,UAAAjb,EAAAgD,OAAAI,YAAAlQ,KAAAunB,cAAAuB,EAAArC,SAAAqC,EAAApC,UACA,GAAAjhB,EAAA,CACA,MAAAiJ,EAAA,IAAArE,KAAA5E,EAAAiJ,MACA1O,KAAAqnB,YAAA2B,KAAA,QAAA,CACAlc,MAAAA,EACA+Z,MAAAphB,EAAAohB,MACAnY,KAAAA,SAGA1O,KAAAqnB,YAAA2B,KAAA,WAAA,CACAnC,MAAAiC,EAAApC,WAGA,GAAA1mB,KAAAknB,cAAAvkB,OAAA3C,KAAAkJ,SAEA,YADAlJ,KAAAknB,cAAAnd,OAAA/J,KAAAknB,cAAA1d,QAAAsf,GAAA,GAEA,CACA,MAAAG,EAAA5d,KAAA4G,IAAAtQ,MAAA,KAAA3B,KAAAknB,cAAAxG,IAAArP,GAAAA,EAAAqV,WACAwC,EAAA,CAAAzC,SAAAwC,EAAAvC,SAAAuC,EAAAjpB,KAAAonB,eACApnB,KAAAknB,cAAAnd,OAAA/J,KAAAknB,cAAA1d,QAAAsf,GAAA,EAAAI,GACAJ,EAAAI,GAGAlpB,KAAAinB,gBACAngB,WAAA,IAAA9G,KAAA+oB,aAAAD,GAAA9oB,KAAA4nB,aAKAtoB,MAAAQ,SAAAknB,iBCpMA,MAAA3Z,cAIA1N,mBACA,OAAA,EAMAA,eACA,MAAA,oBAAAD,OAMAC,kBACA,OAAA,EAMAA,wBACA,MAAAwpB,EAAA9b,cAAAC,YAAA5N,OAAAypB,mBAAAzpB,OAAA0pB,wBAAA,KACA,QAAAD,GAAA,mBAAAA,EAAAjmB,UAAAmmB,kBAMA1pB,oBACA,OAAA2pB,UAAA,UAAAA,SAAAC,SAMA5pB,kBACA,QAAA,WAAAD,OAAA8pB,YAAA9pB,OAAA8pB,UAAAC,OAMA9pB,mBACA,MAAA,OAAAgV,KAAAjV,OAAA8pB,UAAAE,UAGAC,6BACA,IACA,OAAAjqB,OAAA8pB,UAAAE,SACA,MAAAhpB,GACA,MAAA,WAIAkpB,iCACA,MAAA,iBAAAJ,WAAAA,UAAAI,oBACAJ,UAAAI,oBAEA,GAKAtqB,MAAAQ,SAAAuN,eCpEA,MAAAE,WAEA5N,wBACA,OAAA4N,WAAAC,kBAGA7N,+BACA4N,WAAAsc,sBAAAtc,WAAAsc,uBAAA,iBACAtc,WAAAuc,kBAAA,0BACAvc,WAAAwc,oBAAA,iBAAA,SAAA,4BAEAxc,WAAAwc,oBAAA,eAAA,SAAA,qBAJA,GAOA,UACAxc,WAAAsc,sBACA,MAAAnpB,GAEA,MADA6M,WAAAsc,sBAAA,KACAnpB,GASAf,wBAAAqqB,EAAAC,EAAA,UACA,OAAA1c,WAAAuc,kBAAAE,EAAAC,GAQAtqB,+BAAAqqB,EAAAC,EAAA,UAEA,OADAD,EAAAzc,WAAA2c,gBAAAF,GACAzc,WAAAzH,QAAAqkB,YAKA,IAAApiB,QAAA1B,IACA,IACA,MAAA+jB,EAAA,IAAAC,eACAD,EAAAE,KAAA,MAAAN,GAAA,GACAI,EAAAG,aAAA,cACAH,EAAApjB,OAAA,WACAuG,WAAAzH,QAAAmkB,GAAA1c,WAAAzH,QAAAmkB,IAAA,GACA1c,WAAAzH,QAAAmkB,GAAAO,WAAAJ,EAAAK,SACApkB,GAAA,IAEA+jB,EAAAM,QAAA,WACAxqB,IAAA4D,EAAAyJ,kDAAAyc,KACA3jB,GAAA,IAEA+jB,EAAAO,KAAA,MACA,MAAAjqB,GACAR,IAAA4D,EAAAyJ,kDAAAyc,KACA3jB,GAAA,OArBAnG,IAAA4D,EAAAyJ,WAAA,yCACAxF,QAAA1B,SAAA,IAyBA1G,0BAAA8G,EAAAwjB,EAAA,UACA,OAAA1c,WAAAwc,oBAAAtjB,EAAAwjB,GAGAtqB,iCAAA8G,EAAAwjB,EAAA,SAAAW,EAAA,MACA,GAAAX,GAAA1c,WAAAzH,QAAAmkB,IAAA1c,WAAAzH,QAAAmkB,GAAAY,IAAA,OAAA,EACApkB,EAAA8G,WAAAud,kBAAArkB,GAEA,MAAAskB,EAAAxd,WAAAzH,QAAAmkB,IAAA,GACA,OAAA,IAAAliB,QAAAmgB,MAAA7hB,EAAA2kB,KACA,MAAAC,EAAA,IAAAljB,QAAA1B,IACA0kB,EAAAG,qBAAA,KAAA7kB,GAAA,MAEA,GAAA,mBAAA8kB,oBACA,IAAApjB,QAAA1B,IACAkH,WAAAvD,uBAAAigB,GAAA5jB,EACA8kB,cAAA1kB,KAEA8G,WAAAzH,QAAAmkB,GAAA1c,WAAAzH,QAAAmkB,GAAAc,QACA,GAAA,iBAAArrB,aACA,IAAAqI,QAAA1B,IACAkH,WAAAvD,uBAAAigB,GAAA5jB,EACAkH,WAAA6d,mBAAA3kB,EAAAmkB,KAEArd,WAAAzH,QAAAmkB,GAAA1c,WAAAzH,QAAAmkB,GAAAc,OACA,CAAA,GAAA,mBAAAM,QAIA,YADAL,EAAA,2BAFAzd,WAAAzH,QAAAmkB,GAAAoB,QAAA5kB,EAAA4kB,CAAAN,SAKAE,EACAF,EAAAF,MAAAtd,WAAAzH,QAAAmkB,GAAAY,MAAAtd,WAAAzH,QAAAmkB,GAAAc,GACA1kB,GAAA,KAIA1G,wBAAAsqB,EAAA,UACA,mBAAA1c,WAAAvD,uBAAAigB,KACA1c,WAAAvD,uBAAAigB,KACA1c,WAAAvD,uBAAAigB,GAAA,MAIAtqB,0BAAAyG,EAAAwkB,GACA,MAAAtkB,EAAAC,SAAAC,qBAAA,QAAA,GACAC,EAAAF,SAAAG,cAAA,UACAD,EAAAE,KAAA,kBACAF,EAAAG,IAAAR,EACA,MAAAwkB,IACAnkB,EAAAmkB,UAAAA,EACAnkB,EAAA6kB,YAAA,aAEAhlB,EAAAW,YAAAR,GAGA9G,uBAAAqqB,GAGA,MAFA,oBAAA1lB,SAAAA,QAAAC,QAAAylB,KAAA1lB,QAAAC,QAAAylB,KACA,iBAAAuB,YAAA,IAAAvB,EAAAxgB,QAAA,OAAAwgB,KAAAuB,aAAAvB,KACAA,EAGArqB,yBAAA8G,GAGA,MAFA,oBAAAnC,SAAAA,QAAAC,QAAAkC,KAAAnC,QAAAC,QAAAkC,KACA,iBAAA8kB,YAAA,IAAA9kB,EAAA+C,QAAA,OAAA/C,KAAA8kB,aAAA9kB,KACAA,EAGAX,qBACA,MAAA,oBAAAC,OAAAA,OAAA,oBAAArG,OAAAA,OAAA,oBAAAD,KAAAA,KAAA,MAIA8N,WAAAvD,uBAAA,GAEA1K,MAAAQ,SAAAyN,YC5IA,MAAA6B,eACA9P,MAAAQ,SAAAsP,eCDA,MAAAwU,WAMAjkB,qBAAAiY,GACA,OAAAA,EAAAvM,KAAAoF,MAAApF,KAAA8L,SAAAS,EAAAjV,SASAhD,gBAAA6rB,EAAAC,EAAA/L,GACA,SAAAgM,EAAAloB,EAAAwO,EAAAC,GAAA,OAAAzO,EAAAwO,EAAAA,EAAAxO,EAAAyO,EAAAA,EAAAzO,OAEAH,IAAAooB,IAAAA,EAAA,QACApoB,IAAAqc,IAAAA,EAAA8L,EAAApf,YAEAqf,EAAAC,EAAAD,EAAA,EAAAD,EAAApf,YAGA,IAAAoG,GAFAkN,EAAAgM,EAAAhM,EAAA,EAAA8L,EAAApf,aAEAqf,EAKA,OAJAjZ,EAAA,IACAA,EAAA,GAGA,IAAA7E,WAAA6d,EAAAhd,OAAAgd,EAAAzF,WAAA0F,EAAAjZ,GAQA7S,sBAAAgsB,EAAA3f,GACA,MAAAmF,EAAAwa,EAAAhpB,OAEA,GAAAqJ,EAAAmF,EACA,OAEA,MAAAya,EAAA3oB,MAAAmd,KAAA,IAAAnd,MAAA+I,GAAA,CAAA0F,EAAAhP,IAAAA,SACAkpB,EAAAlL,IAAAhe,GAAAipB,EAAAjpB,IACA,MAAAmpB,EAAA5oB,MAAAmd,KAAA,IAAAnd,MAAA+I,GAAA,CAAA0F,EAAAhP,IAAAsJ,EAAAtJ,EAAA,GAEA,OAAA,CACA,IAAAA,EAAAsJ,EAAA,EAAA8f,GAAA,EACA,IAAAppB,KAAAmpB,EACA,GAAAD,EAAAlpB,KAAAA,EAAAyO,EAAAnF,EAAA,CACA8f,GAAA,EACA,MAGA,IAAAA,EACA,OAEAF,EAAAlpB,IAAA,EACA,IAAA,MAAAqJ,KAAA9I,MAAAmd,KAAA,IAAAnd,MAAA+I,EAAAtJ,EAAA,GAAA,CAAAgP,EAAA1F,IAAAtJ,EAAAsJ,EAAA,GACA4f,EAAA7f,GAAA6f,EAAA7f,EAAA,GAAA,QAEA6f,EAAAlL,IAAAhe,GAAAipB,EAAAjpB,MAIApD,MAAAQ,SAAA8jB,YCnEA,MAAAmI,OAMApsB,YAAAqsB,EAAAjpB,EAAA,oBACA,IAAAipB,EACA,MAAA,IAAAzgB,MAAAxI,IAIAzD,MAAAQ,SAAAisB,QCZA,MAAAE,WAMAtsB,mBAAAusB,EAAAC,EAAAF,WAAAG,OACA,OAAAH,WAAAI,aAAAH,EAAAC,GASAxsB,oBAAAusB,EAAAC,GACA,MAAA3Z,EAAA0Z,EAAAvpB,OACA,GAAA,IAAA6P,EACA,OAAAnI,KAAAiiB,MAAA,IAAA3e,WAAA,IAEA,GAAA,IAAA6E,EACA,OAAA2Z,EAAAD,EAAA,IAGA,MAAAK,EAAAlhB,KAAAuJ,MAAApC,EAAA,GACAga,EAAAN,EAAA/oB,MAAA,EAAAopB,GACAE,EAAAP,EAAA/oB,MAAAopB,GACAG,EAAAT,WAAAI,aAAAG,EAAAL,GACAQ,EAAAV,WAAAI,aAAAI,EAAAN,GACA,OAAA9hB,KAAAiiB,MAAA3hB,YAAAC,kBAAA8hB,EAAAxc,YAAAyc,EAAAzc,cAQAvQ,aAAAuiB,GACA,GAAAA,aAAA7X,KACA,OAAA6X,EAEA,GAAA,mBAAAA,EAAAxT,KACA,OAAAwT,EAAAxT,OAEA,GAAA,mBAAAwT,EAAAhS,UACA,OAAA7F,KAAAiiB,MAAApK,EAAAhS,aAEA,GAAAgS,aAAAvU,WACA,OAAAtD,KAAAiiB,MAAApK,GAEA,MAAA,IAAA3W,MAAA,gFAGAjM,MAAAQ,SAAAmsB,YCtDA,MAAAW,WAIAjtB,YAAAktB,GACA,IAAA5pB,MAAAiP,QAAA2a,KAAA1O,YAAA8H,QAAA4G,EAAAlqB,SACAkqB,EAAAC,KAAAC,KAAAA,aAAAC,iBAAA,MAAA,IAAAzhB,MAAA,mBAKAvL,KAAAitB,OAAAJ,EASAltB,eAAAusB,EAAAgB,EAAAf,EAAAF,WAAAG,OACA,MAAAe,EAAAhB,EAAAe,GACAE,EAAA,GAEA,OADAR,WAAAS,SAAAnB,EAAAiB,EAAAC,EAAAjB,GACA,IAAAS,WAAAQ,GAWAztB,gBAAAusB,EAAAiB,EAAAC,EAAAjB,GACA,MAAA3Z,EAAA0Z,EAAAvpB,OACA,IAAA+L,EACA,GAAA,IAAA8D,EAEA,MAAA,CAAA8a,cAAA,EAAAC,MADA7e,EAAArE,KAAAiiB,MAAA,IAAA3e,WAAA,KAGA,GAAA,IAAA6E,EAEA,MAAA,CAAA8a,cADA5e,EAAAyd,EAAAD,EAAA,KACAlR,OAAAmS,GAAAI,MAAA7e,GAGA,MAAA6d,EAAAlhB,KAAAuJ,MAAApC,EAAA,GACAga,EAAAN,EAAA/oB,MAAA,EAAAopB,GACAE,EAAAP,EAAA/oB,MAAAopB,IACAe,aAAAE,EAAAD,MAAAb,GAAAE,WAAAS,SAAAb,EAAAW,EAAAC,EAAAjB,IACAmB,aAAAG,EAAAF,MAAAZ,GAAAC,WAAAS,SAAAZ,EAAAU,EAAAC,EAAAjB,GAGA,OAFAzd,EAAArE,KAAAiiB,MAAA3hB,YAAAC,kBAAA8hB,EAAAxc,YAAAyc,EAAAzc,cAEAsd,GACAJ,EAAA/jB,KAAA,IAAA2jB,eAAAL,GAAA,IACA,CAAAW,cAAA,EAAAC,MAAA7e,IACA+e,GACAL,EAAA/jB,KAAA,IAAA2jB,eAAAN,GAAA,IACA,CAAAY,cAAA,EAAAC,MAAA7e,IAGA,CAAA4e,cAAA,EAAAC,MAAA7e,GAQA/O,YAAAutB,EAAAf,EAAAF,WAAAG,OAEA,IAAAsB,EAAAvB,EAAAe,GACA,IAAA,MAAAS,KAAA3tB,KAAAitB,OAAA,CACA,MAAAT,EAAAmB,EAAAnB,KACA9d,EAAAif,EAAAjf,KACAsJ,EAAA,IAAA5N,aAAA,EAAAsE,EAAAkf,gBACApB,GAAA9d,EAAAwB,UAAA8H,GACA0V,EAAAxd,UAAA8H,GACAwU,GAAA9d,EAAAwB,UAAA8H,GACA0V,EAAArjB,KAAAiiB,MAAAtU,GAEA,OAAA0V,EAQA/tB,iBAAAktB,GACA,MAAAgB,EAAAhB,EAAAlqB,OACAmrB,EAAAziB,KAAAG,KAAAqiB,EAAA,GACAE,EAAA,IAAApgB,WAAAmgB,GAEA,IAAA,IAAAprB,EAAA,EAAAA,EAAAmrB,EAAAnrB,IACAmqB,EAAAnqB,GAAA8pB,OACAuB,EAAA1iB,KAAAoF,MAAA/N,EAAA,KAAA,MAAAA,EAAA,GAIA,OAAAqrB,EAOApuB,mBAAAif,GACA,MAAAiP,EAAAjP,EAAAoG,YACA8I,EAAAziB,KAAAG,KAAAqiB,EAAA,GACAE,EAAAnP,EAAA8G,KAAAoI,GAEAjB,EAAA,GACA,IAAA,IAAAnqB,EAAA,EAAAA,EAAAmrB,EAAAnrB,IAAA,CACA,MAAA8pB,EAAA,IAAAuB,EAAA1iB,KAAAoF,MAAA/N,EAAA,IAAA,MAAAA,EAAA,GACAsrB,EAAApP,EAAAoG,YACAtW,EAAArE,KAAAiF,YAAAsP,EAAAoP,GACAnB,EAAAxjB,KAAA,IAAA2jB,eAAAte,EAAA8d,IAEA,OAAA,IAAAI,WAAAC,GAOAltB,UAAAif,IACAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAxI,WAAAplB,KAAAitB,OAAAtqB,QACAic,EAAAhT,MAAAghB,WAAAqB,UAAAjuB,KAAAitB,SAEA,IAAA,MAAAU,KAAA3tB,KAAAitB,OACArO,EAAAwG,WAAAuI,EAAAjf,KAAAsf,WACAL,EAAAjf,KAAAwB,UAAA0O,GAEA,OAAAA,EAIAgP,qBAEA,OAAA,EADAviB,KAAAG,KAAAxL,KAAAitB,OAAAtqB,OAAA,GAGA3C,KAAAitB,OAAA9G,OAAA,CAAA+H,EAAAP,IAAAO,EAAA,EAAAP,EAAAjf,KAAAkf,eAAA,GAOAjuB,OAAAuiB,GACA,OAAAA,aAAA0K,YACA5sB,KAAAitB,OAAAtqB,SAAAuf,EAAA+K,OAAAtqB,QACA3C,KAAAitB,OAAAkB,MAAA,CAAAR,EAAAjrB,IAAAirB,EAAA3S,OAAAkH,EAAA+K,OAAAvqB,KAIAmqB,YACA,OAAA7sB,KAAAitB,QAGA3tB,MAAAQ,SAAA8sB,YAEA,MAAAI,eAKArtB,YAAA+O,EAAA8d,GACAxsB,KAAAosB,MAAA1d,EACA1O,KAAAouB,MAAA5B,EAIA9d,WACA,OAAA1O,KAAAosB,MAIAI,WACA,OAAAxsB,KAAAouB,MAOAzuB,OAAAuiB,GACA,OAAAA,aAAA8K,gBACAhtB,KAAAosB,MAAApR,OAAAkH,EAAAxT,OACA1O,KAAAouB,QAAAlM,EAAAsK,MAGAltB,MAAAQ,SAAAktB,gBClMA,MAAAxF,OAMA7nB,uBAAA0uB,GACA,OAAA,IAAAhe,UAAAge,GAAAzT,MAAA4M,OAAA8G,mBAAAzT,eAQAlb,uBAAA4uB,GACA,OAAA,IAAAle,UAAAke,GAAA3b,IAAA4U,OAAA8G,mBAQA3uB,qBAAA6uB,GACA,GAAAA,GAAA,EAAA,OAAA,IAAAne,UAAA,GACA,MAAAoe,EAAApjB,KAAA2G,IAAA3G,KAAAoF,OAAA+d,EAAA,GAAAhH,OAAAkH,kBAAAlH,OAAAmH,mBAAA,GACA,OAAA,IAAAte,UAAAmX,OAAAoH,sBAAAzU,KAAA9O,KAAAC,IAAA,EAAAmjB,IAQA9uB,iBAAA6uB,GACA,OAAAA,GAAAhH,OAAAqH,qBAAArH,OAAAsH,mBACAN,EAAAhH,OAAAkH,iBAAAlH,OAAAmH,mBAAAnH,OAAAsH,mBAEAtH,OAAAuH,qBAAAvH,OAAAmH,mBAAAtjB,KAAAoF,OAAA+d,EAAA,GAAAhH,OAAAkH,mBAQA/uB,oBAAA6uB,GACA,GAAAA,GAAAhH,OAAAqH,qBAAA,OAAAL,EAAA,GAAAhH,OAAAsH,mBAEA,MAAAE,EAAAxH,OAAAqH,qBAAArH,OAAAsH,mBACAG,EAAAzH,OAAAuH,oBAAAvH,OAAAmH,mBACA,GAAAH,GAAAhH,OAAAkH,iBACA,OAAAM,GAAAR,EAAAhH,OAAAqH,qBAAA,GAAAI,EAIA,IAAAC,EAAAF,GAAAxH,OAAAkH,iBAAAlH,OAAAqH,sBAAAI,EAEAE,EAAAX,EAAAhH,OAAAkH,iBACAb,EAAA,EAEA,KAAAsB,EAAA3H,OAAAkH,kBAAAb,EAAArG,OAAAmH,oBACAO,GAAA1H,OAAAkH,iBAAAlH,OAAAuH,qBAAAvH,OAAAmH,mBAAAd,GACAsB,GAAA3H,OAAAkH,iBACAb,GAAA,EASA,OANAA,GAAArG,OAAAmH,mBACAO,IAAAC,EAAA,GAAA3H,OAAAsH,mBAEAI,IAAAC,EAAA,GAAA3H,OAAAuH,qBAAAvH,OAAAmH,mBAAAd,GAGAqB,EASAvvB,8BAAA8rB,EAAA/L,GACA,MAAA0P,EAAA3D,EAAA,EAAAA,EAAA,EACA4D,EAAA3P,EAAA,EAAAA,EAAA,EACA,GAAA0P,GAAAC,EAAA,OAAA,EAEA,MAAAC,EAAA9H,OAAAkH,iBAAAlH,OAAAmH,mBACA,IAAAY,EAAAF,EAAAD,EACA,GAAAC,GAAA7H,OAAAqH,sBAAAO,EAAAE,EACA,OAAAC,EAAA/H,OAAAsH,mBAGA,MAAAG,EAAAzH,OAAAuH,oBAAAvH,OAAAmH,mBACA,GAAAU,GAAA7H,OAAAkH,iBACA,OAAAU,GAAA5H,OAAAqH,sBACArH,OAAAqH,qBAAAO,EAAA,GAAA5H,OAAAsH,oBAAAO,EAAA7H,OAAAqH,qBAAA,GAAAI,EAEAM,EAAAN,EAGA,MAAAO,EAAAnkB,KAAAoF,OAAA2e,EAAA,GAAA5H,OAAAkH,kBACA,IAMAe,EANAC,EAAArkB,KAAAoF,OAAA4e,EAAA,GAAA7H,OAAAkH,kBAEA,GAAAc,IAAAE,EACA,OAAAH,EAAA/H,OAAAuH,qBAAAvH,OAAAmH,mBAAAa,GAIA,IACAG,EADAC,EAAA,EAEA,GAAAR,GAAA5H,OAAAqH,qBACAY,GAAAjI,OAAAqH,qBAAAO,EAAA,GAAA5H,OAAAsH,oBAAAtH,OAAAkH,iBAAAlH,OAAAqH,sBAAAI,MACA,CAEAQ,IADAD,EAAA,GAAAhI,OAAAkH,iBACAU,EAAA,GAAA5H,OAAAuH,qBAAAvH,OAAAmH,mBAAAa,GAEA,GAAAH,EAAAC,EACAI,EAAAlI,OAAAmH,mBACAgB,GAAAN,EAAAC,EAAA,GAAA9H,OAAAsH,uBACA,CAEAa,GAAAN,EADAK,EAAAlI,OAAAkH,iBACA,GAAAlH,OAAAuH,qBAAAvH,OAAAmH,mBAAAe,GAEA,IAAA,IAAAhtB,EAAA8sB,EAAA,EAAA9sB,EAAAgtB,EAAAhtB,IACAktB,GAAApI,OAAAkH,iBAAAlH,OAAAuH,qBAAAvH,OAAAmH,mBAAAjsB,GAEA,OAAA+sB,EAAAG,EAAAD,EAQAhwB,aAAA6uB,GACA,GAAAA,GAAA,EAAA,OAAA,IAAAne,UAAA,GACA,MAAAwf,EAAAxkB,KAAAoF,OAAA+d,EAAA,GAAAhH,OAAAsI,0BACA,OAAAD,EAAArI,OAAAuI,6BACA,IAAA1f,UAAAmX,OAAAwI,gBAAApd,IAAAvH,KAAAC,IAAA,GAAAukB,IAEA,IAAAxf,UAAA,GAQA1Q,iBAAA6uB,GACA,OAAAA,EAAAhH,OAAAyI,wCAAAzI,OAAA0I,mBACA1I,OAAA2I,gBAAA3I,OAAA4I,kBAAA/kB,KAAAoF,MAAA+d,EAAAhH,OAAA6I,8BAQA1wB,6BAAA6uB,GACA,GAAAA,GAAAhH,OAAA8I,qCACA9B,EAAAhH,OAAAyI,wCAAA,OAAAzI,OAAA+I,wBAEA,MAAAC,EAAAhJ,OAAAiJ,UAAAjC,GACA,OAAAnjB,KAAAoF,MAAA,IAAA+f,IASAhJ,OAAAsH,mBAAA,EAOAtH,OAAAuH,oBAAA,EAOAvH,OAAAqH,qBAAA,KAOArH,OAAA0I,mBAAA,IAOA1I,OAAA2I,gBAAA,KAOA3I,OAAA4I,kBAAA,KAOA5I,OAAA6I,6BAAA,KAOA7I,OAAAC,iBAAA,IAAApX,UAAA,GAAA/E,IAAA,KAOAkc,OAAA+I,wBAAA,IAOA/I,OAAAyI,wCAAA,QAOAzI,OAAAkJ,iCAAA,EAOAlJ,OAAAmJ,qCAAA,IAOAnJ,OAAAoJ,qCAAA,GAOApJ,OAAA8I,oCAAA,QAOA9I,OAAAqJ,wCAAA,IAOArJ,OAAAsJ,wCAAA,GAOAtJ,OAAAuJ,4BAAA,IAUAvJ,OAAA8G,kBAAA,KAQA9G,OAAAwJ,eAAA,EAOAxJ,OAAAoH,qBAAA,KAOApH,OAAAmH,mBAAA,GAOAnH,OAAAkH,iBAAA,KAUAlH,OAAAyJ,EAAA,IAQAzJ,OAAA0J,EAAA,IAQA1J,OAAA2J,MAAA,IAQA3J,OAAA4J,wBAAA,IAUA5J,OAAA6J,kBAAA,GASA7J,OAAAwI,eAAA,IAOAxI,OAAAsI,yBAAA,KAOAtI,OAAAuI,6BAAA,EAEAzwB,MAAAQ,SAAA0nB,QCvYA,MAAA8J,aAKA3xB,OAAAuiB,GACA,OAAAA,aAAAoP,cAAA3mB,YAAAqQ,OAAAhb,KAAAkQ,YAAAgS,EAAAhS,aAOAvQ,QAAAuiB,GACA,OAAAvX,YAAA8G,QAAAzR,KAAAkQ,YAAAgS,EAAAhS,aAGAvQ,WACA,OAAAK,KAAA2gB,WAOAhhB,UAAAif,IAKAjf,WACA,OAAAK,KAAA2gB,WAMAhhB,WACA,OAAAgL,YAAAgW,SAAA3gB,KAAAkQ,aAMAvQ,QACA,OAAAgL,YAAA4mB,MAAAvxB,KAAAkQ,aAMAvQ,WACA,OAAAgL,YAAAsY,SAAAjjB,KAAAkQ,aAOAvQ,cAAAkjB,EAAA,IAAAC,GACA,OAAAnY,YAAA6mB,cAAAxxB,KAAAkQ,YAAA2S,EAAAC,IAIAxjB,MAAAQ,SAAAwxB,cCnEA,MAAAjnB,aAAAinB,aAMA3xB,YAAA8xB,EAAAzD,EAAA3jB,KAAAc,UAAAumB,SACA,GAAA,OAAAD,EACAA,EAAA,IAAA9jB,WAAAtD,KAAAuD,QAAAogB,QACA,CACA,KAAAyD,aAAA9jB,YAAA,MAAA,IAAApC,MAAA,2BACA,GAAAkmB,EAAA9uB,SAAA0H,KAAAuD,QAAAogB,GAAA,MAAA,IAAAziB,MAAA,6BAEApE,QACAnH,KAAA2xB,KAAAF,EAEAzxB,KAAA4xB,WAAA5D,EAQAruB,aAAAiY,GACA,OAAAvN,KAAAwnB,QAAAja,GAOAjY,eAAAiY,GACA,OAAA,IAAAvN,KAAAA,KAAAynB,eAAAla,GAAAvN,KAAAc,UAAAumB,SAQA/xB,YAAAiY,GACA,OAAAvN,KAAA0nB,QAAAna,GAOAjY,qBAAAiY,GACA,OAAA,IAAAvN,iBAAA4B,aAAAC,oBAAAic,eAAAvQ,GAAAvN,KAAAc,UAAA0C,SAOAlO,cAAAiY,GACA,OAAA,IAAAvN,KAAAA,KAAA2Y,cAAApL,GAAAvN,KAAAc,UAAA6mB,QAOAryB,cAAAiY,GACA,OAAA,IAAAvN,KAAAA,KAAAC,cAAAsN,GAAAvN,KAAAc,UAAAC,QAOAzL,iBAAAiY,GACA,OAAA,IAAAvN,KAAAA,KAAA4nB,iBAAAra,GAAAvN,KAAAc,UAAA+mB,WAOAvyB,kBAAAiY,GACA,OAAAvN,KAAA8nB,UAAA9nB,KAAA2Y,cAAApL,IAOAjY,iBAAAiY,GACA,OAAA,IAAAvN,KAAAA,KAAA+nB,iBAAAxa,GAAAvN,KAAAc,UAAAknB,WAQA1yB,eAAAiY,EAAAoW,GAEA,OAAAA,GACA,KAAA3jB,KAAAc,UAAAumB,QAAA,OAAArnB,KAAAwnB,QAAAja,GACA,KAAAvN,KAAAc,UAAA6mB,OAAA,OAAA3nB,KAAAioB,OAAA1a,GAGA,QAAA,MAAA,IAAArM,MAAA,2BASA5L,mBAAAif,EAAAoP,EAAA3jB,KAAAc,UAAAumB,SACA,OAAA,IAAArnB,KAAAuU,EAAA8G,KAAArb,KAAAuD,QAAAogB,IAAAA,GAOAruB,UAAAif,GAGA,OAFAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAhiB,MAAA5L,KAAA2xB,MACA/S,EAQAjf,SAAA8rB,EAAA/L,GACA,OAAA1f,KAAA2xB,KAAA1S,SAAAwM,EAAA/L,GAIAkO,qBACA,OAAAvjB,KAAAa,KAAA1I,IAAAxC,KAAA4xB,YAIA5N,YACA,OAAAhkB,KAAA2xB,KAIA3D,gBACA,OAAAhuB,KAAA4xB,WAOAjyB,OAAAuiB,GACA,OAAAA,aAAA7X,MAAA6X,EAAA0P,aAAA5xB,KAAA4xB,YAAAzqB,MAAA6T,OAAAkH,GAQAviB,eAAA+O,EAAAsf,EAAA3jB,KAAAc,UAAAumB,SACA,GAAAhjB,aAAArE,KAAA,OAAAqE,EACA,IACA,OAAA,IAAArE,KAAAM,YAAA4nB,QAAA7jB,EAAArE,KAAAa,KAAA1I,IAAAwrB,IAAAA,GACA,MAAAttB,GACA,MAAA,IAAA6K,MAAA,wBAOA5L,UACA,OAAAK,KAAAuxB,QAOA5xB,kBAAA6gB,GACA,OAAA,IAAAnW,KAAAM,YAAAiW,WAAAJ,IAOA7gB,eAAA0hB,GACA,OAAA,IAAAhX,KAAAM,YAAAyX,QAAAf,IAOA1hB,iBAAA0S,GACA,OAAAhI,KAAAmoB,WAAAngB,GAOA1S,kBAAA0S,GACA,IACA,OAAAhI,KAAA+X,QAAA/P,GACA,MAAA3R,IAIA,IACA,OAAA2J,KAAAuW,WAAAvO,GACA,MAAA3R,IAIA,MAAA,IAAA6K,MAAA,uBAOA5L,cAAAuiB,GACA,OAAAA,aAAA7X,KAOA1K,eAAAquB,GACA,MAAAhpB,EAAAqF,KAAAa,KAAA1I,IAAAwrB,GACA,GAAA,iBAAAhpB,EAAA,MAAA,IAAAuG,MAAA,0BACA,OAAAvG,EAOArF,sBAAAgN,GACA,GAAAU,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAtD,KAAAuD,QAAAvD,KAAAc,UAAAumB,UAEA,OADA5jB,WAAA2kB,YAAA/kB,EAAA,IAAAC,WAAAhB,IACAe,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAC,EAAA9D,KAAAuD,QAAAvD,KAAAc,UAAAumB,SACAtjB,EAAAH,OAAAI,WAAAF,GACAG,EAAAL,OAAAI,WAAA1B,EAAAhK,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAA3B,EAAAhK,QAAAsF,IAAA0E,GACA,MAAArH,EAAA2I,OAAAykB,gBAAAtkB,EAAAE,EAAA3B,EAAAhK,QACA,GAAA,IAAA2C,EACA,MAAAA,EAEA,MAAAoJ,EAAA,IAAAf,WAAAQ,GAEA,OADAO,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAD,IACAO,EACA,MAAAhO,GAEA,MADAR,IAAA4D,EAAAuG,KAAA3J,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KASArO,qBAAAgN,GACA,GAAAU,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAtD,KAAAuD,QAAAvD,KAAAc,UAAA6mB,SAEA,OADAlkB,WAAA6kB,YAAAjlB,EAAA,IAAAC,WAAAhB,IACAe,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAC,EAAA9D,KAAAuD,QAAAvD,KAAAc,UAAA6mB,QACA5jB,EAAAH,OAAAI,WAAAF,GACAG,EAAAL,OAAAI,WAAA1B,EAAAhK,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAA3B,EAAAhK,QAAAsF,IAAA0E,GACAsB,OAAA2kB,gBAAAxkB,EAAAE,EAAA3B,EAAAhK,QACA,MAAA+L,EAAA,IAAAf,WAAAQ,GAEA,OADAO,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAD,IACAO,EACA,MAAAhO,GAEA,MADAR,IAAA4D,EAAAuG,KAAA3J,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KASArO,qBAAAgN,GACA,GAAAU,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAtD,KAAAuD,QAAAvD,KAAAc,UAAAC,SAEA,OADA0C,WAAA+kB,YAAAnlB,EAAA,IAAAC,WAAAhB,IACAe,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAC,EAAA9D,KAAAuD,QAAAvD,KAAAc,UAAAC,QACAgD,EAAAH,OAAAI,WAAAF,GACAG,EAAAL,OAAAI,WAAA1B,EAAAhK,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAA3B,EAAAhK,QAAAsF,IAAA0E,GACAsB,OAAA6kB,gBAAA1kB,EAAAE,EAAA3B,EAAAhK,QACA,MAAA+L,EAAA,IAAAf,WAAAQ,GAEA,OADAO,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAD,IACAO,EACA,MAAAhO,GAEA,MADAR,IAAA4D,EAAAuG,KAAA3J,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KASArO,wBAAAgN,GACA,GAAAU,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAtD,KAAAuD,QAAAvD,KAAAc,UAAA+mB,YAEA,OADApkB,WAAAilB,eAAArlB,EAAA,IAAAC,WAAAhB,IACAe,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAC,EAAA9D,KAAAuD,QAAAvD,KAAAc,UAAA+mB,WACA9jB,EAAAH,OAAAI,WAAAF,GACAG,EAAAL,OAAAI,WAAA1B,EAAAhK,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAA3B,EAAAhK,QAAAsF,IAAA0E,GACAsB,OAAA+kB,WAAA1kB,EAAA3B,EAAAhK,OAAAyL,GACA,MAAAM,EAAA,IAAAf,WAAAQ,GAEA,OADAO,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAD,IACAO,EACA,MAAAhO,GAEA,MADAR,IAAA4D,EAAAuG,KAAA3J,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KASArO,wBAAAgN,GACA,GAAAU,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAtD,KAAAuD,QAAAvD,KAAAc,UAAAknB,YAEA,OADAvkB,WAAAmlB,eAAAvlB,EAAA,IAAAC,WAAAhB,IACAe,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAC,EAAA9D,KAAAuD,QAAAvD,KAAAc,UAAAknB,WACAjkB,EAAAH,OAAAI,WAAAF,GACAG,EAAAL,OAAAI,WAAA1B,EAAAhK,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAF,EAAA3B,EAAAhK,QAAAsF,IAAA0E,GACAsB,OAAAilB,WAAA5kB,EAAA3B,EAAAhK,OAAAyL,GACA,MAAAM,EAAA,IAAAf,WAAAQ,GAEA,OADAO,EAAAzG,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAD,IACAO,EACA,MAAAhO,GAEA,MADAR,IAAA4D,EAAAuG,KAAA3J,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,MASA3D,KAAAc,UAAA,CACAumB,QAAA,EACA7jB,QAAA,EACAmkB,OAAA,EACA5mB,OAAA,EACA8mB,UAAA,EACAG,UAAA,GAMAhoB,KAAAc,UAAAvI,SAAA,SAAAuwB,GACA,OAAAA,GACA,KAAA9oB,KAAAc,UAAAumB,QAAA,MAAA,UACA,KAAArnB,KAAAc,UAAA0C,QAAA,MAAA,UACA,KAAAxD,KAAAc,UAAA6mB,OAAA,MAAA,SACA,KAAA3nB,KAAAc,UAAAC,OAAA,MAAA,SACA,KAAAf,KAAAc,UAAA+mB,UAAA,MAAA,YACA,KAAA7nB,KAAAc,UAAAknB,UAAA,MAAA,YAEA,MAAA,IAAA9mB,MAAA,2BAOAlB,KAAAc,UAAAonB,QAAA,SAAAvE,GACA,GAAA,iBAAAA,EAAA,OAAAA,EACA,OAAAA,GACA,IAAA,UAAA,OAAA3jB,KAAAc,UAAAumB,QACA,IAAA,UAAA,OAAArnB,KAAAc,UAAA0C,QACA,IAAA,SAAA,OAAAxD,KAAAc,UAAA6mB,OACA,IAAA,SAAA,OAAA3nB,KAAAc,UAAAC,OACA,IAAA,YAAA,OAAAf,KAAAc,UAAA+mB,UACA,IAAA,YAAA,OAAA7nB,KAAAc,UAAAknB,UAEA,MAAA,IAAA9mB,MAAA,2BAMAlB,KAAAa,KAAA,IAAAzD,IACA4C,KAAAa,KAAAjD,IAAAoC,KAAAc,UAAAumB,QAAA,IACArnB,KAAAa,KAAAjD,IAAAoC,KAAAc,UAAA0C,QAAA,IACAxD,KAAAa,KAAAjD,IAAAoC,KAAAc,UAAA6mB,OAAA,IACA3nB,KAAAa,KAAAjD,IAAAoC,KAAAc,UAAAC,OAAA,IACAf,KAAAa,KAAAjD,IAAAoC,KAAAc,UAAA+mB,UAAA,IACA7nB,KAAAa,KAAAjD,IAAAoC,KAAAc,UAAAknB,UAAA,IAEAhoB,KAAA+oB,KAAA,IAAA/oB,KAAA,IAAAsD,WAAA,KACArO,MAAAQ,SAAAuK,MCrcA,MAAAgpB,kBAAA/B,aAKA3xB,YAAAuiB,GACA,OAAAA,EACA,IAAAmR,UAAA,IAAA1lB,WAAAuU,EAAAyP,OADAzP,EAQAviB,YAAA8xB,GAEA,GADAtqB,UACAsqB,aAAA9jB,YAAA,MAAA,IAAApC,MAAA,2BACA,GAAAkmB,EAAA9uB,SAAA0wB,UAAAnoB,KAAA,MAAA,IAAAK,MAAA,6BACAvL,KAAA2xB,KAAAF,EAOA9xB,cAAA2zB,GACA,OAAA,IAAAD,UAAAA,UAAAE,iBAAAD,EAAA3B,OAMAhyB,WACA,OAAA0zB,UAAAG,mBAAAxzB,KAAA2xB,MAOAhyB,WAAA8zB,GAGA,OAFAA,EAAAA,EAAAtwB,SACAuwB,KAAA,CAAAriB,EAAAO,IAAAP,EAAAI,QAAAG,IACAyhB,UAAAM,mCAAAF,GAOA9zB,mBAAAif,GACA,OAAA,IAAAyU,UAAAzU,EAAA8G,KAAA2N,UAAAnoB,OAOAvL,eAAAuiB,GACA,IAAAA,EAAA,MAAA,IAAA3W,MAAA,6BACA,GAAA2W,aAAAmR,UAAA,OAAAnR,EACA,IACA,OAAA,IAAAmR,UAAA1oB,YAAA4nB,QAAArQ,EAAAmR,UAAAnoB,OACA,MAAAxK,GACA,MAAA,IAAA6K,MAAA,8BAQA5L,UAAAif,GAGA,OAFAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAhiB,MAAA5L,KAAA2xB,MACA/S,EAIAgP,qBACA,OAAAyF,UAAAnoB,KAOAvL,OAAAuiB,GACA,OAAAA,aAAAmR,WAAAlsB,MAAA6T,OAAAkH,GAMAviB,OACA,OAAA0K,KAAAupB,UAAA5zB,KAAAkQ,YAAA/M,MAAA,IAOAxD,QAAAuiB,GACA,OAAAvX,YAAA8G,QAAAzR,KAAA2xB,KAAAzP,EAAAyP,MAMAhyB,YACA,OAAAk0B,QAAAC,SAAA9zB,KAAA0O,QAMA/O,WACA,OAAA,IAAAo0B,OAAA/zB,KAAA0O,OAAAuQ,SAAA,EAAA,KAOAtf,0CAAA8zB,GACA,MAAAO,EAAAP,EAAA/S,IAAA1U,GAAAA,EAAAkE,aACA+jB,EAAAZ,UAAAa,gBAAAF,GACAG,EAAAd,UAAAe,mCAAAJ,EAAAC,GACA,OAAA,IAAAZ,UAAAc,GAOAx0B,0BAAA00B,GACA,GAAAA,EAAAjoB,aAAAinB,UAAAnoB,KACA,MAAAK,MAAA,sBAEA,MAAA+oB,EAAA,IAAA3mB,WAAA,IAEA,GADA1B,aAAAM,IAAAkK,gBAAA6d,GACAjnB,cAAAI,WAAA,CACAK,WAAAymB,wBAAAD,GACA,MAAA5mB,EAAA,IAAAC,WAAA0lB,UAAAmB,iBAGA,OAFA1mB,WAAA2mB,+BAAA/mB,EAAA,IAAAC,WAAA0mB,IACAvmB,WAAA4mB,6BACAhnB,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAymB,EAAA1mB,OAAAI,WAAA,IACA,IAAAV,WAAAM,OAAA2mB,MAAApmB,OAAAmmB,EAAA,IAAA1sB,IAAAqsB,GACArmB,OAAA4mB,oBAAAF,GAEA,MAAAvmB,EAAAH,OAAAI,WAAAglB,UAAAmB,iBACAM,EAAA,IAAAnnB,WAAAM,OAAA2mB,MAAApmB,OAAAJ,EAAAilB,UAAAmB,iBAEAlmB,EAAAL,OAAAI,WAAAglB,UAAAnoB,MACA,IAAAyC,WAAAM,OAAA2mB,MAAApmB,OAAAF,EAAA+kB,UAAAnoB,MACAjD,IAAAosB,GAEApmB,OAAA8mB,2BAAA3mB,EAAAE,GACA,MAAA0mB,EAAA,IAAArnB,WAAA0lB,UAAAmB,iBAEA,OADAQ,EAAA/sB,IAAA6sB,GACAE,EACA,MAAAt0B,GAEA,MADAR,IAAA4D,EAAAuvB,UAAA3yB,GACAA,EACA,QACAuN,OAAAgnB,8BACA5xB,IAAA2K,GAAAC,OAAAU,aAAAX,KASArO,wBAAA2zB,GACA,GAAAA,EAAAlnB,aAAA8oB,WAAAhqB,KACA,MAAAK,MAAA,sBAEA,MAAA+oB,EAAA,IAAA3mB,WAAA,IAEA,GADA1B,aAAAM,IAAAkK,gBAAA6d,GACAjnB,cAAAI,WAAA,CACAK,WAAAymB,wBAAAD,GACA,MAAA5mB,EAAA,IAAAC,WAAA0lB,UAAAnoB,MAGA,OAFA4C,WAAAqnB,6BAAAznB,EAAA,IAAAC,WAAA2lB,IACAxlB,WAAA4mB,6BACAhnB,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAymB,EAAA1mB,OAAAI,WAAA,IACA,IAAAV,WAAAM,OAAA2mB,MAAApmB,OAAAmmB,EAAA,IAAA1sB,IAAAqsB,GACArmB,OAAA4mB,oBAAAF,GAEA,MAAAvmB,EAAAH,OAAAI,WAAAglB,UAAAnoB,MACAkqB,EAAA,IAAAznB,WAAAM,OAAA2mB,MAAApmB,OAAAJ,EAAAilB,UAAAnoB,MAEAoD,EAAAL,OAAAI,WAAAilB,EAAA3wB,QACA0yB,EAAA,IAAA1nB,WAAAM,OAAA2mB,MAAApmB,OAAAF,EAAA4mB,WAAAhqB,MACAmqB,EAAAptB,IAAAqrB,GAEArlB,OAAAqnB,yBAAAlnB,EAAAilB,UAAAnoB,KAAAoD,GACA+mB,EAAAE,KAAA,GACA,MAAAlB,EAAA,IAAA1mB,WAAA0lB,UAAAnoB,MAEA,OADAmpB,EAAApsB,IAAAmtB,GACAf,EACA,MAAA3zB,GAEA,MADAR,IAAA4D,EAAAuvB,UAAA3yB,GACAA,EACA,QACAuN,OAAAgnB,8BACA5xB,IAAA2K,GAAAC,OAAAU,aAAAX,KASArO,uBAAA8zB,GACA,GAAAA,EAAA3G,KAAAuH,GAAAA,EAAAjoB,aAAAinB,UAAAnoB,MACA,MAAAK,MAAA,sBAEA,MAAAiqB,EAAA,IAAA7nB,WAAA8lB,EAAA9wB,OAAA0wB,UAAAnoB,MACA,IAAA,IAAAxI,EAAA,EAAAA,EAAA+wB,EAAA9wB,SAAAD,EACA8yB,EAAAvtB,IAAAwrB,EAAA/wB,GAAAA,EAAA2wB,UAAAnoB,MAEA,GAAAmC,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAtD,KAAAuD,QAAAvD,KAAAc,UAAA6mB,SAEA,OADAlkB,WAAA2nB,4BAAA/nB,EAAA8nB,EAAA/B,EAAA9wB,OAAA0wB,UAAAnoB,MACAwC,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAC,EAAA9D,KAAAuD,QAAAvD,KAAAc,UAAA6mB,QACA5jB,EAAAH,OAAAI,WAAAF,GACAunB,EAAAznB,OAAAI,WAAAmnB,EAAA7yB,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAknB,EAAAF,EAAA7yB,QAAAsF,IAAAutB,GACAvnB,OAAA0nB,wBAAAvnB,EAAAsnB,EAAAjC,EAAA9wB,OAAA0wB,UAAAnoB,MACA,MAAA0qB,EAAA,IAAAjoB,WAAAQ,GAEA,OADAynB,EAAA3tB,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAD,IACAynB,EACA,MAAAl1B,GAEA,MADAR,IAAA4D,EAAAuvB,UAAA3yB,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KAUArO,6BAAA00B,EAAAJ,GACA,GAAAI,EAAAjoB,aAAAinB,UAAAnoB,MACA+oB,EAAA7nB,aAAA/B,KAAAuD,QAAAvD,KAAAc,UAAA6mB,QACA,MAAAzmB,MAAA,sBAEA,GAAA8B,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAA0lB,UAAAnoB,MAEA,OADA4C,WAAA+nB,kCAAAnoB,EAAA,IAAAC,WAAAsmB,GAAA,IAAAtmB,WAAA0mB,IACA3mB,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAE,EAAAH,OAAAI,WAAAglB,UAAAnoB,MACA4qB,EAAA7nB,OAAAI,WAAAgmB,EAAA1xB,QACAozB,EAAA9nB,OAAAI,WAAA4lB,EAAAtxB,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAsnB,EAAAzB,EAAA1xB,QAAAsF,IAAAosB,GACA,IAAA1mB,WAAAM,OAAAM,OAAAC,OAAAunB,EAAA9B,EAAAtxB,QAAAsF,IAAAgsB,GACAhmB,OAAA+nB,8BAAA5nB,EAAA2nB,EAAAD,GACA,MAAAG,EAAA,IAAAtoB,WAAA0lB,UAAAnoB,MAEA,OADA+qB,EAAAhuB,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAilB,UAAAnoB,OACA+qB,EACA,MAAAv1B,GAEA,MADAR,IAAA4D,EAAAuvB,UAAA3yB,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KAUArO,0CAAA8zB,EAAAQ,GACA,GAAAR,EAAA3G,KAAAuH,GAAAA,EAAAjoB,aAAAinB,UAAAnoB,OACA+oB,EAAA7nB,aAAA/B,KAAAuD,QAAAvD,KAAAc,UAAA6mB,QACA,MAAAzmB,MAAA,sBAEA,MAAAiqB,EAAA,IAAA7nB,WAAA8lB,EAAA9wB,OAAA0wB,UAAAnoB,MACA,IAAA,IAAAxI,EAAA,EAAAA,EAAA+wB,EAAA9wB,SAAAD,EACA8yB,EAAAvtB,IAAAwrB,EAAA/wB,GAAAA,EAAA2wB,UAAAnoB,MAEA,GAAAmC,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAA0lB,UAAAnoB,MAEA,OADA4C,WAAAooB,+CAAAxoB,EAAA,IAAAC,WAAAsmB,GAAAuB,EAAA/B,EAAA9wB,OAAA0wB,UAAAnoB,MACAwC,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAE,EAAAH,OAAAI,WAAAglB,UAAAnoB,MACAwqB,EAAAznB,OAAAI,WAAAmnB,EAAA7yB,QACAozB,EAAA9nB,OAAAI,WAAA4lB,EAAAtxB,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAknB,EAAAF,EAAA7yB,QAAAsF,IAAAutB,GACA,IAAA7nB,WAAAM,OAAAM,OAAAC,OAAAunB,EAAA9B,EAAAtxB,QAAAsF,IAAAgsB,GACAhmB,OAAAkoB,2CAAA/nB,EAAA2nB,EAAAL,EAAAjC,EAAA9wB,OAAA0wB,UAAAnoB,MACA,MAAAkrB,EAAA,IAAAzoB,WAAA0lB,UAAAnoB,MAEA,OADAkrB,EAAAnuB,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAAJ,EAAAilB,UAAAnoB,OACAkrB,EACA,MAAA11B,GAEA,MADAR,IAAA4D,EAAAuvB,UAAA3yB,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,MAMAqlB,UAAAmB,gBAAA,GACAnB,UAAAnoB,KAAA,GAEA5L,MAAAQ,SAAAuzB,WCnVA,MAAAgD,kBAAA/E,aAKA3xB,YAAAuiB,GACA,IAAAA,EAAA,OAAAA,EAEA,MAAAla,EAAA,IAAA2F,WAAAuU,EAAAyP,MACA,OAAA,IAAA0E,UAAAruB,GAOArI,YAAA8xB,GAEA,GADAtqB,UACAsqB,aAAA9jB,YAAA,MAAA,IAAApC,MAAA,2BACA,GAAAkmB,EAAA9uB,SAAA0zB,UAAAnrB,KAAA,MAAA,IAAAK,MAAA,6BACAvL,KAAA2xB,KAAAF,EASA9xB,cAAA2zB,EAAAe,EAAAjvB,GACA,OAAA,IAAAixB,UAAAA,UAAAC,iBAAAhD,EAAA3B,KAAA0C,EAAAkC,WAAAnxB,IAQAzF,6BAAA62B,EAAAC,GACA,MAAAtC,EAAAkC,UAAAK,0BAAAF,EAAAtmB,YAAAumB,EAAA/V,IAAApP,GAAAA,EAAApB,cACA,OAAA,IAAAmmB,UAAAlC,GAOAx0B,mBAAAif,GACA,OAAA,IAAAyX,UAAAzX,EAAA8G,KAAA2Q,UAAAnrB,OAOAvL,eAAAuiB,GACA,IAAAA,EAAA,MAAA,IAAA3W,MAAA,4BACA,GAAA2W,aAAAmU,UAAA,OAAAnU,EACA,IACA,OAAA,IAAAmU,UAAA1rB,YAAA4nB,QAAArQ,EAAAmU,UAAAnrB,OACA,MAAAxK,GACA,MAAA,IAAA6K,MAAA,6BAQA5L,UAAAif,GAGA,OAFAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAhiB,MAAA5L,KAAA2xB,MACA/S,EAIAgP,qBACA,OAAAyI,UAAAnrB,KAQAvL,OAAA00B,EAAAjvB,GACA,OAAAixB,UAAAM,iBAAAtC,EAAAkC,WAAAnxB,EAAApF,KAAA2xB,MAOAhyB,OAAAuiB,GACA,OAAAA,aAAAmU,WAAAlvB,MAAA6T,OAAAkH,GAQAviB,iCAAAi3B,EAAAC,GACA,OAAAR,UAAAS,4BAAAD,GAOAl3B,mCAAAk3B,GACA,OAAAA,EAAA1Q,OAAA,CAAA4Q,EAAAC,KACA,IAAAD,EAAA,OAAAC,EACA,MAAAvrB,EAAAsrB,EAAA5zB,MAAA,EAAA8zB,iBAAAC,WACAC,EAAAJ,EAAA5zB,MAAA8zB,iBAAAC,WACAE,EAAAJ,EAAA7zB,MAAA8zB,iBAAAC,WACAhJ,EAAAmI,UAAAgB,YAAAF,EAAAC,GACA,OAAAzsB,YAAAC,kBAAAa,EAAAyiB,KASAvuB,mBAAA0R,EAAAO,GACA,GAAAP,EAAAjF,aAAA6qB,iBAAAC,WAAAtlB,EAAAxF,aAAA6qB,iBAAAC,UACA,MAAA3rB,MAAA,sBAEA,GAAA8B,cAAAI,WAAA,CACA,MAAAC,EAAA,IAAAC,WAAAspB,iBAAAC,WAEA,OADAppB,WAAAwpB,2BAAA5pB,EAAA,IAAAC,WAAA0D,GAAA,IAAA1D,WAAAiE,IACAlE,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAqpB,EAAAtpB,OAAAI,WAAA4oB,iBAAAC,WACAM,EAAAvpB,OAAAI,WAAAgD,EAAA1O,QACA80B,EAAAxpB,OAAAI,WAAAuD,EAAAjP,QACA,IAAAgL,WAAAM,OAAAM,OAAAC,OAAAgpB,EAAAnmB,EAAA1O,QAAAsF,IAAAoJ,GACA,IAAA1D,WAAAM,OAAAM,OAAAC,OAAAipB,EAAA7lB,EAAAjP,QAAAsF,IAAA2J,GACA3D,OAAAypB,uBAAAH,EAAAC,EAAAC,GACA,MAAAvJ,EAAA,IAAAvgB,WAAAspB,iBAAAC,WAEA,OADAhJ,EAAAjmB,IAAA,IAAA0F,WAAAM,OAAAM,OAAAC,OAAA+oB,EAAAN,iBAAAC,YACAhJ,EACA,MAAAxtB,GAEA,MADAR,IAAA4D,EAAAuyB,UAAA31B,GACAA,EACA,aACA2C,IAAA2K,GAAAC,OAAAU,aAAAX,KAWArO,wBAAA2zB,EAAAe,EAAAtxB,GACA,GAAAuwB,EAAAlnB,aAAA8oB,WAAAhqB,MAAAmpB,EAAAjoB,YAAAinB,UAAAmB,gBACA,MAAAjpB,MAAA,sBAEA,MAAA+oB,EAAA,IAAA3mB,WAAA,IAEA,GADA1B,aAAAM,IAAAkK,gBAAA6d,GACAjnB,cAAAI,WAAA,CACAK,WAAAymB,wBAAAD,GACA,MAAA5mB,EAAA,IAAAC,WAAA0oB,UAAAnrB,MAGA,OAFA4C,WAAA6pB,4BAAAjqB,EAAA,IAAAC,WAAA5K,GAAA,IAAA4K,WAAA0mB,GAAA,IAAA1mB,WAAA2lB,IACAxlB,WAAA4mB,6BACAhnB,EACA,CACA,IAAAM,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAymB,EAAA1mB,OAAAI,WAAA,IACA,IAAAV,WAAAM,OAAA2mB,MAAApmB,OAAAmmB,EAAA,IACA1sB,IAAAqsB,GACArmB,OAAA4mB,oBAAAF,GACA,MAAAiD,EAAA3pB,OAAAI,WAAAgoB,UAAAnrB,MACA2sB,EAAA,IAAAlqB,WAAAM,OAAA2mB,MAAApmB,OAAAopB,EAAAvB,UAAAnrB,MACA4sB,EAAA7pB,OAAAI,WAAAtL,EAAAJ,QACA,IAAAgL,WAAAM,OAAA2mB,MAAApmB,OAAAspB,EAAA/0B,EAAAJ,QAAAsF,IAAAlF,GACA,MAAAg1B,EAAA9pB,OAAAI,WAAAgmB,EAAA1xB,QACA,IAAAgL,WAAAM,OAAA2mB,MAAApmB,OAAAupB,EAAA1D,EAAA1xB,QAAAsF,IAAAosB,GACA,MAAA2D,EAAA/pB,OAAAI,WAAAilB,EAAA3wB,QACA0yB,EAAA,IAAA1nB,WAAAM,OAAA2mB,MAAApmB,OAAAwpB,EAAA1E,EAAA3wB,QACA0yB,EAAAptB,IAAAqrB,GAEArlB,OAAAgqB,wBAAAL,EAAAE,EAAA/0B,EAAAqJ,WAAA2rB,EAAAC,GACA3C,EAAAE,KAAA,GAEA,MAAA2C,EAAA,IAAAvqB,WAAA0oB,UAAAnrB,MAEA,OADAgtB,EAAAjwB,IAAA4vB,GACAK,EACA,MAAAx3B,GAEA,MADAR,IAAA4D,EAAAuyB,UAAA31B,GACAA,EACA,QACAuN,OAAAgnB,8BACA5xB,IAAA2K,GAAAC,OAAAU,aAAAX,KAWArO,wBAAA00B,EAAAtxB,EAAAm1B,GACA,MAAA5D,EAAA,IAAA3mB,WAAA,IAEA,GADA1B,aAAAM,IAAAkK,gBAAA6d,GACAjnB,cAAAI,WAAA,CACAK,WAAAymB,wBAAAD,GACA,MAAAhvB,IAAAwI,WAAAqqB,8BAAA,IAAAxqB,WAAAuqB,GAAA,IAAAvqB,WAAA5K,GAAA,IAAA4K,WAAA0mB,IAEA,OADAvmB,WAAA4mB,6BACApvB,EACA,CACA,IAAA0I,EACA,IACAA,EAAAC,OAAAC,YACA,MAAAymB,EAAA1mB,OAAAI,WAAA,IACA,IAAAV,WAAAM,OAAA2mB,MAAApmB,OAAAmmB,EAAA,IACA1sB,IAAAqsB,GACArmB,OAAA4mB,oBAAAF,GAEA,MAAAoD,EAAA9pB,OAAAI,WAAAgmB,EAAA1xB,QACA,IAAAgL,WAAAM,OAAA2mB,MAAApmB,OAAAupB,EAAA1D,EAAA1xB,QAAAsF,IAAAosB,GACA,MAAAyD,EAAA7pB,OAAAI,WAAAtL,EAAAJ,QACA,IAAAgL,WAAAM,OAAA2mB,MAAApmB,OAAAspB,EAAA/0B,EAAAJ,QAAAsF,IAAAlF,GACA,MAAAq1B,EAAAnqB,OAAAI,WAAA6pB,EAAAv1B,QAGA,OAFA,IAAAgL,WAAAM,OAAA2mB,MAAApmB,OAAA4pB,EAAAF,EAAAv1B,QAAAsF,IAAAiwB,KAEAjqB,OAAAoqB,0BAAAD,EAAAN,EAAA/0B,EAAAqJ,WAAA2rB,GACA,MAAAr3B,GAEA,MADAR,IAAA4D,EAAAuyB,UAAA31B,GACAA,EACA,QACAuN,OAAAgnB,8BACA5xB,IAAA2K,GAAAC,OAAAU,aAAAX,MAMAqoB,UAAAnrB,KAAA,GAEA5L,MAAAQ,SAAAu2B,WC5PA,MAAAxC,gBAAAvC,aAKA3xB,YAAAuiB,GACA,IAAAA,EAAA,OAAAA,EACA,MAAAla,EAAA,IAAA2F,WAAAuU,EAAAyP,MACA,OAAA,IAAAkC,QAAA7rB,GAOArI,gBAAA+O,GACA,OAAA,IAAAmlB,QAAAnlB,EAAAuQ,UAAA4U,QAAAyE,kBAGA34B,YAAA8xB,GAEA,GADAtqB,UACAsqB,aAAA9jB,YAAA,MAAA,IAAApC,MAAA,2BACA,GAAAkmB,EAAA9uB,SAAAkxB,QAAAyE,gBAAA,MAAA,IAAA/sB,MAAA,6BACAvL,KAAA2xB,KAAAF,EAQA9xB,mBAAAif,GACA,OAAA,IAAAiV,QAAAjV,EAAA8G,KAAAmO,QAAAyE,kBAQA34B,UAAAif,GAGA,OAFAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAhiB,MAAA5L,KAAA2xB,MACA/S,EAQAjf,SAAA8rB,EAAA/L,GACA,OAAA1f,KAAA2xB,KAAA1S,SAAAwM,EAAA/L,GAMAkO,qBACA,OAAAiG,QAAAyE,gBAOA34B,OAAAuiB,GACA,OAAAA,aAAA2R,SACA1sB,MAAA6T,OAAAkH,GAMAviB,eAAA44B,GACA,GAAAA,aAAA1E,QAAA,OAAA0E,EACA,GAAA,iBAAAA,EAAA,OAAA1E,QAAArB,WAAA+F,GACA,MAAA,IAAAhtB,MAAA,0BAMA5L,UACA,OAAAK,KAAAw4B,wBAGA74B,kBAAA0S,GACA,IACA,OAAAwhB,QAAA4E,wBAAApmB,GACA,MAAA3R,IAIA,IACA,OAAAmzB,QAAAzR,QAAA/P,GACA,MAAA3R,IAIA,IACA,OAAAmzB,QAAAjT,WAAAvO,GACA,MAAA3R,IAIA,MAAA,IAAA6K,MAAA,0BAOA5L,kBAAA6gB,GACA,OAAA,IAAAqT,QAAAlpB,YAAAiW,WAAAJ,IAOA7gB,eAAA0hB,GACA,OAAA,IAAAwS,QAAAlpB,YAAAyX,QAAAf,IAOA1hB,kBAAA0S,GACA,IAAArS,KAAA04B,gBAAArmB,GACA,MAAA,IAAA9G,MAAA,0BAGA,OAAA,IAAAsoB,QAAA8E,OAAAC,WAAAvmB,IAOA1S,+BAAA0S,GACA,OAAAwhB,QAAAzR,QAAA/P,GAMA1S,WACA,OAAAg5B,OAAAE,SAAA74B,KAAAkQ,aAOAvQ,sBAAAm5B,GAAA,GACA,OAAA94B,KAAAuxB,QAOA5xB,uBAAA44B,GACA,OAAAI,OAAAD,gBAAAH,IAIA1E,QAAAyE,gBAAA,GACAzE,QAAAkF,SAAA,GACAlF,QAAAT,KAAA,IAAAS,QAAA,IAAAlmB,WAAAkmB,QAAAyE,kBACAzE,QAAAmF,kBAAA,IAAAnF,QAAA,IAAAlmB,WAAAkmB,QAAAyE,kBACAh5B,MAAAQ,SAAA+zB,SCzJA,MAAA8E,OAKAh5B,eAAAusB,GACA,IAAA+M,EAAA,EAEA,IAAA,IAAA3iB,EAAA,EAAAA,EAAA4V,EAAAvpB,SAAA2T,EAAA,CACA,MAAA4iB,EAAAD,GAAA,GACAA,GAAA,SAAAA,IAAA,EAAA/M,EAAA5V,GACA,IAAA,IAAA5T,EAAA,EAAAA,EAAA,IAAAA,EACAw2B,GAAAx2B,EAAA,IACAu2B,GAAAN,OAAAQ,UAAAz2B,IAIA,OAAAu2B,EAOAt5B,iBAAAy5B,GACA,MAAAvyB,EAAA,GACA,IAAAyP,EACA,IAAAA,EAAA,EAAAA,EAAA8iB,EAAAz2B,SAAA2T,EACAzP,EAAAwC,KAAA+vB,EAAA5nB,WAAA8E,IAAA,GAGA,IADAzP,EAAAwC,KAAA,GACAiN,EAAA,EAAAA,EAAA8iB,EAAAz2B,SAAA2T,EACAzP,EAAAwC,KAAA,GAAA+vB,EAAA5nB,WAAA8E,IAEA,OAAAlM,aAAAgW,KAAAvZ,GAQAlH,sBAAAy5B,EAAAh0B,GAEA,OAAAuzB,OAAAU,QAAAjvB,aAAA4N,OAAA,CAAA2gB,OAAAW,UAAAF,GAAAh0B,OAAAuzB,OAAAY,SAQA55B,sBAAAy5B,EAAAh0B,GACA,MAAA8mB,EAAA9hB,aAAA4N,OAAA,CAAA2gB,OAAAW,UAAAF,GAAAh0B,EAAAgF,aAAAgW,KAAA,CAAA,EAAA,EAAA,EAAA,EAAA,EAAA,MAGAzF,EAAAge,OAAAU,QAAAnN,GAAAyM,OAAAY,SACA1yB,EAAA,GACA,IAAA,IAAAyP,EAAA,EAAAA,EAAA,IAAAA,EACAzP,EAAAwC,KAAAsR,GAAA,GAAA,EAAArE,GAAA,IAEA,OAAAlM,aAAAgW,KAAAvZ,GAQAlH,oBAAAy5B,EAAAh0B,GACA,MAAAo0B,EAAApvB,aAAA4N,OAAA,CAAA5S,EAAAuzB,OAAAc,eAAAL,EAAAh0B,KACA,IAAAyB,EAAAuyB,EAAA,IAEA,IAAA,IAAA9iB,EAAA,EAAAA,EAAAkjB,EAAA72B,SAAA2T,EACAzP,GAAA8xB,OAAAe,QAAApnB,OAAAknB,EAAAljB,IAGA,OAAAzP,EAOAlH,oBAAAg6B,GACA,IAAArjB,EACAsjB,GAAA,EACAC,GAAA,EACA,IAAAvjB,EAAA,EAAAA,EAAAqjB,EAAAh3B,SAAA2T,EAAA,CACA,GAAAqjB,EAAAnoB,WAAA8E,GAAA,IAAAqjB,EAAAnoB,WAAA8E,GAAA,IACA,OAAA,KAEAqjB,EAAAnoB,WAAA8E,IAAA,IAAAqjB,EAAAnoB,WAAA8E,IAAA,MACAsjB,GAAA,GAEAD,EAAAnoB,WAAA8E,IAAA,IAAAqjB,EAAAnoB,WAAA8E,IAAA,KACAujB,GAAA,GAGA,GAAAD,GAAAC,EACA,OAAA,KAGA,MAAAC,GADAH,EAAAA,EAAAh2B,eACAo2B,YAAA,KACA,GAAAD,EAAA,GAAAA,EAAA,EAAAH,EAAAh3B,QAAAg3B,EAAAh3B,OAAA,GACA,OAAA,KAEA,MAAAy2B,EAAAO,EAAA7kB,UAAA,EAAAglB,GACA10B,EAAA,GACA,IAAAkR,EAAAwjB,EAAA,EAAAxjB,EAAAqjB,EAAAh3B,SAAA2T,EAAA,CACA,MAAA1S,EAAA+0B,OAAAe,QAAAlwB,QAAAmwB,EAAArnB,OAAAgE,IACA,IAAA,IAAA1S,EACA,OAAA,KAEAwB,EAAAiE,KAAAzF,GAGA,OAAA+0B,OAAAqB,eAAAZ,EAAAhvB,aAAAgW,KAAAhb,IAIA,CAAAg0B,IAAAA,EAAAh0B,KAAAgF,aAAAgW,KAAAhb,EAAAjC,MAAA,EAAAiC,EAAAzC,OAAA,KAHA,KAoBAhD,mBAAAyF,EAAA60B,EAAAC,EAAAC,GAAA,GACA,IAAA/T,EAAA,EACAgU,EAAA,EACA,MAAAvzB,EAAA,GACAwzB,GAAA,GAAAH,GAAA,EAEA,IAAA,IAAA5jB,EAAA,EAAAA,EAAAlR,EAAAzC,SAAA2T,EAAA,CACA,MAAAwN,EAAA1e,EAAAkR,GACA,GAAAwN,EAAA,GAAAA,GAAAmW,GAAA,EACA,OAAA,KAIA,IAFA7T,EAAAA,GAAA6T,EAAAnW,EACAsW,GAAAH,EACAG,GAAAF,GACAE,GAAAF,EACArzB,EAAAwC,KAAA+c,GAAAgU,EAAAC,GAIA,GAAAF,EACAC,EAAA,GACAvzB,EAAAwC,KAAA+c,GAAA8T,EAAAE,EAAAC,QAEA,GAAAD,GAAAH,GAAA7T,GAAA8T,EAAAE,EAAAC,EACA,OAAA,KAGA,OAAAjwB,aAAAgW,KAAAvZ,GAaAlH,gBAAA26B,EAAAC,EAAA5B,OAAA6B,KACA,MAAAC,EAAA9B,OAAA+B,YAAAtwB,aAAAgW,KAAAka,GAAA,EAAA,GAEA,GAAA,OAAAG,EACA,MAAA,IAAAlvB,MAAA,iDAGA,OAAAotB,OAAAgC,aAAAJ,EAAAnwB,aAAA4N,OAAA,CAAA5N,aAAAgW,KAAA,CADA,IACAqa,KASA96B,kBAAA26B,EAAAC,EAAA5B,OAAA6B,KACA,MAAAl1B,EAAAqzB,OAAAiC,aAAAN,GAEA,GAAA,OAAAh1B,EACA,MAAA,IAAAiG,MAAA,0BAGA,MAAA6tB,IAAAA,EAAAh0B,KAAAA,GAAAE,EAEA,GAAA8zB,IAAAmB,EACA,MAAA,IAAAhvB,4BAAAgvB,aAAAnB,KAGA,MAAAxa,EAAA+Z,OAAA+B,YAAAt1B,EAAAjC,MAAA,GAAA,EAAA,GAAA,GAEA,GAAA,OAAAyb,EACA,MAAA,IAAArT,MAAA,qCAGA,OAAA,IAAAnB,aAAAwU,GAQAjf,uBAAAw0B,GACA,QAAAA,EAAAxS,MAAA,+CAIAgX,OAAAY,SAAA,EACAZ,OAAA6B,IAAA,KACA7B,OAAAe,QAAA,mCACAf,OAAAQ,UAAA,CAAA,UAAA,UAAA,UAAA,WAAA,WACA75B,MAAAQ,SAAA64B,QCvPA,MAAAkC,QAKAl7B,YAAAgH,EAAAm0B,GACA,MAAAC,EAAA,IAAA1qB,UAAAyqB,GACA,IAAA3c,YAAA8H,QAAAtf,GAAA,MAAA,IAAA4E,MAAA,kBACA,IAAA4S,YAAA4G,UAAAgW,GAAA,MAAA,IAAAxvB,MAAA,qBAGAvL,KAAAg7B,MAAAr0B,EAEA3G,KAAAi7B,SAAAF,EAQAp7B,mBAAAif,GACA,MAAAjY,EAAAiY,EAAAoG,YAGA,GAFApG,EAAAiF,WAEAgX,QAAAK,SAAAC,IAAAx0B,GACA,MAAA,IAAA4E,MAAA,wBAGA,OAAAsvB,QAAAK,SAAA14B,IAAAmE,GAAA2I,YAAAsP,GAQAjf,UAAAif,GAIA,OAHAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAxI,WAAAplB,KAAAg7B,OACApc,EAAAwc,aAAAp7B,KAAAi7B,UACArc,EAMAgP,qBACA,OAAA,GASAjuB,OAAAuiB,GACA,OAAAvX,YAAAqQ,OAAAhb,KAAAkQ,YAAAgS,EAAAhS,aAGAvQ,WACA,sBAAAK,KAAAg7B,kBAAAh7B,KAAAi7B,SAAAr4B,aAMAjD,eAAAuiB,GACA,OAAAA,aAAA2Y,QAAA3Y,EACA2Y,QAAAQ,UAAAnZ,GAOAviB,iBAAA27B,GACA,IAAAA,QAAAj4B,IAAAi4B,EAAA30B,KAAA,MAAA,IAAA4E,MAAA,mBACA,MAAA5E,EAAAk0B,QAAAU,KAAAhJ,QAAA+I,EAAA30B,MACA,OAAAk0B,QAAAK,SAAA14B,IAAAmE,GAAA00B,UAAAC,GAMA37B,UACA,MAAA,CACAgH,KAAAk0B,QAAAU,KAAA34B,SAAA5C,KAAA2G,MACAm0B,QAAA96B,KAAA86B,QAAAl4B,YAOAk4B,cACA,OAAA96B,KAAAi7B,SAIAt0B,WACA,OAAA3G,KAAAg7B,MAOAr7B,YAAAm7B,GAAA,MAAA,IAAAvvB,MAAA,wBASA5L,wBAAA67B,EAAAhN,EAAAiN,EAAAC,GAAA,GACA,GAAAA,EAaA,CACA,GAAAlN,EAAAgN,EAAAG,qBACAnN,GAAAgN,EAAAG,oBAAAnU,OAAAuJ,4BACA,MAAA,IAAA8J,QAAAe,cAEA,OAAA57B,KAAA67B,YAAA77B,KAAAi7B,SAAApf,KAAA2f,EAAA1X,OAAAjI,KAAA2f,EAAAM,MAlBA,CACA,MAAAC,EAAA/7B,KAAAi7B,SAAAtf,MAAA6f,EAAA1X,OAAAnI,MAAA6f,EAAAM,KACA,GAAAC,EAAA/kB,GAAA,GACA,MAAA,IAAA6jB,QAAAmB,aAEA,GAAAxN,EAAAgN,EAAAG,qBACAnN,GAAAgN,EAAAG,oBAAAnU,OAAAuJ,4BACA,MAAA,IAAA8J,QAAAe,cAEA,GAAAH,EAAAQ,oBAAAT,GACA,MAAA,IAAAX,QAAAqB,uBAEA,OAAAl8B,KAAA67B,YAAAE,IAgBAp8B,wBAAA67B,EAAAhN,EAAAkN,GAAA,GACA,GAAAA,EAEA,CACA,MAAAK,EAAA/7B,KAAAi7B,SAAAtf,MAAA6f,EAAA1X,OACA,GAAAiY,EAAA/kB,GAAA,GACA,MAAA,IAAA6jB,QAAAmB,aAEA,OAAAh8B,KAAA67B,YAAAE,GANA,OAAA/7B,KAAA67B,YAAA77B,KAAAi7B,SAAApf,KAAA2f,EAAA1X,QAgBAnkB,oBAAA67B,EAAAhN,EAAAkN,GAAA,GACA,MAAA,IAAAnwB,MAAA,uBAMA5L,YACA,OAAAK,OAAA66B,QAAAsB,QAMAx8B,eACA,OAAAK,KAAAi7B,SAAAlgB,GAAA,KAAA/a,KAAAo8B,YAOAz8B,mBAAAyF,GACA,MAAA,GAOAzF,oBAAA08B,GACA,MAAA,IASAxB,QAAAU,KAAA,CAKAe,MAAA,EAKAC,QAAA,EAKAC,KAAA,GAMA3B,QAAAU,KAAA34B,SAAA,SAAA+D,GACA,OAAAA,GACA,KAAAk0B,QAAAU,KAAAe,MAAA,MAAA,QACA,KAAAzB,QAAAU,KAAAgB,QAAA,MAAA,UACA,KAAA1B,QAAAU,KAAAiB,KAAA,MAAA,OAEA,MAAA,IAAAjxB,MAAA,yBAMAsvB,QAAAU,KAAAhJ,QAAA,SAAA5rB,GACA,GAAA,iBAAAA,EAAA,OAAAA,EACA,OAAAA,GACA,IAAA,QAAA,OAAAk0B,QAAAU,KAAAe,MACA,IAAA,UAAA,OAAAzB,QAAAU,KAAAgB,QACA,IAAA,OAAA,OAAA1B,QAAAU,KAAAiB,KAEA,MAAA,IAAAjxB,MAAA,yBAcAsvB,QAAAK,SAAA,IAAAzzB,IACAozB,QAAAmB,aAAA,cAAAzwB,MAAA5L,cAAAwH,MAAA,oBACA0zB,QAAAqB,uBAAA,cAAA3wB,MAAA5L,cAAAwH,MAAA,+BACA0zB,QAAA4B,WAAA,cAAAlxB,MAAA5L,cAAAwH,MAAA,kBACA0zB,QAAAe,cAAA,cAAArwB,MAAA5L,cAAAwH,MAAA,qBACA7H,MAAAQ,SAAA+6B,SC3QA,MAAA6B,cAKA/8B,YAAA26B,EAAAqC,GACA,KAAArC,aAAAzG,SAAA,MAAA,IAAAtoB,MAAA,qBAGAvL,KAAA48B,SAAAtC,EAEAt6B,KAAA68B,SAAAF,EAOAh9B,mBAAAif,GACA,OAAA,IAAA8d,cAAA7I,QAAAvkB,YAAAsP,GAAAic,QAAAvrB,YAAAsP,IAOAjf,eAAAuiB,GACA,OAAAA,aAAAwa,cAAAxa,EACAwa,cAAArB,UAAAnZ,GAMAviB,iBAAA27B,GACA,OAAA,IAAAoB,cAAA7I,QAAAtB,QAAA+I,EAAAhB,SAAAO,QAAAtI,QAAA+I,EAAAqB,UAOAh9B,QAAAuiB,GACA,OAAAliB,KAAA48B,SAAAnrB,QAAAyQ,EAAA0a,UAMAtC,cACA,OAAAt6B,KAAA48B,SAMAD,cACA,OAAA38B,KAAA68B,SAMAl9B,UAAAif,GAIA,OAHAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,gBACA5tB,KAAA48B,SAAA1sB,UAAA0O,GACA5e,KAAA68B,SAAA3sB,UAAA0O,GACA5e,KAMA4tB,qBACA,OAAA5tB,KAAA48B,SAAAhP,eAAA5tB,KAAA68B,SAAAjP,eAMAjuB,WACA,OAAAK,KAAA48B,SAAAE,WAMAn9B,UACA,MAAA,CACA26B,QAAAt6B,KAAAs6B,QAAAyC,UACAJ,QAAA38B,KAAA28B,QAAAI,YAKAz9B,MAAAQ,SAAA48B,eC3FA,MAAAM,qBAAAnC,QAKAl7B,YAAAuiB,GACA,OAAAA,EACA,IAAA8a,aAAA9a,EAAA+Y,UADA/Y,EAOAviB,YAAAm7B,EAAA,GACA3zB,MAAA0zB,QAAAU,KAAAe,MAAAxB,GAOAn7B,mBAAAif,GAEA,GADAA,EAAAoG,cACA6V,QAAAU,KAAAe,MAAA,MAAA,IAAA/wB,MAAA,wBAEA,MAAAuvB,EAAAlc,EAAAqe,cACA,OAAA,IAAAD,aAAAlC,GAMAn7B,iBAAAuiB,GACA,IAAAA,EAAA,MAAA,IAAA3W,MAAA,mBACA,OAAA,IAAAyxB,aAAA9a,EAAA4Y,SAQAn7B,OAAAuiB,GACA,OAAAA,aAAA8a,cACAh9B,KAAAg7B,QAAA9Y,EAAA8Y,OACAh7B,KAAAi7B,SAAAlgB,GAAAmH,EAAA+Y,UAGAt7B,WACA,8BAAAK,KAAAi7B,SAAAr4B,cAOAjD,iCAAA67B,GACA,OAAA0B,eAAAC,kBAAA3B,GAOA77B,iCAAA67B,GACA,QAAAA,EAAAp2B,KAAAgH,WAAA,IAQAzM,YAAAm7B,GACA,OAAA,IAAAkC,aAAAlC,GASAn7B,wBAAA67B,EAAAhN,EAAAkN,GAAA,GACA,IAAAA,EAAA,CAGA,GAFAF,EAAA4B,QAAAC,YAAAC,KAAAtE,sBACAwC,EAAA+B,gBAAAv9B,KAAAg7B,OAEA,MAAA,IAAAzvB,MAAA,eAGA,OAAApE,MAAAq2B,wBAAAhC,EAAAhN,EAAAkN,GASA/7B,oBAAA67B,EAAAhN,EAAAkN,GAAA,GACA,OAAAA,GAAAF,EAAA+B,gBAAAv9B,KAAAg7B,OAAAQ,EAAA4B,QAAAC,YAAAC,KAAAtE,mBAEA6B,QAAAK,SAAA14B,IAAAg5B,EAAA+B,eAAAE,OAAAz9B,KAAAi7B,SAAAzM,EAAAgN,GAEAx7B,KAMAL,YACA,OAAAK,KAAAi7B,UAAAj7B,KAAAi7B,SAAAlgB,GAAA,GAOApb,mBAAAyF,GACA,OAAAy1B,QAAA6C,YAAAt4B,GAOAzF,oBAAA08B,GACA,IACA,MAAAsB,EAAAT,eAAA5tB,YAAA,IAAAlF,aAAAiyB,IACA,MAAA,CACAnE,UAAAyF,EAAAzF,UAAA3G,QACA8C,UAAAsJ,EAAAtJ,UAAA9C,QACAqM,OAAAD,EAAAtJ,UAAAwJ,YAAAd,UACAe,WAAAH,EAAAI,WAAAlR,MAAAlqB,QAEA,MAAAjC,GACA,OAAAm6B,QAAAmD,aAAA3B,KAKAxB,QAAAsB,QAAA,IAAAa,aAAA,GACAnC,QAAAK,SAAAjzB,IAAA4yB,QAAAU,KAAAe,MAAAU,cACA19B,MAAAQ,SAAAk9B,cCpJA,MAAAiB,iBAAApD,QAKAl7B,YAAAgH,EAAAm0B,GACA3zB,MAAAR,EAAAm0B,GAOAn7B,iCAAA67B,GACA,QAAAA,EAAA0C,UAAAljB,OAAAwgB,EAAA2C,8BAYAx+B,wBAAA67B,EAAAhN,EAAAkN,GAAA,GACA,IAAAA,GAAAF,EAAA4B,QAAAC,YAAAC,KAAAtE,mBAEA,MAAA,IAAAztB,MAAA,cAEA,OAAApE,MAAAq2B,wBAAAhC,EAAAhN,EAAAkN,GAUA/7B,oBAAA67B,EAAAhN,EAAAkN,GAAA,GACA,OAAAA,GAAAF,EAAA4B,QAAAC,YAAAC,KAAAtE,mBAEA,IAAAgE,aAAAh9B,KAAA86B,SAEA96B,MAIAV,MAAAQ,SAAAm+B,UClDA,MAAAG,iCAAAH,SAUAt+B,YAAAm7B,EAAA,EAAAuD,EAAAxK,QAAAT,KAAA8K,EAAArK,QAAAT,KAAAkL,EAAAj0B,KAAA+oB,KAAAmL,EAAA,EAAAC,EAAA,EAAAC,EAAA3D,GACA3zB,MAAA0zB,QAAAU,KAAAiB,KAAA1B,GACA,MAAA4D,EAAA,IAAAruB,UAAAouB,GACA,KAAAJ,aAAAxK,SAAA,MAAA,IAAAtoB,MAAA,4BACA,KAAA2yB,aAAArK,SAAA,MAAA,IAAAtoB,MAAA,+BACA,KAAA+yB,aAAAj0B,MAAA,MAAA,IAAAkB,MAAA,sBACA,IAAA4S,YAAA8H,QAAAsY,IAAA,IAAAA,EAAA,MAAA,IAAAhzB,MAAA,uBACA,IAAA4S,YAAAwgB,SAAAH,GAAA,MAAA,IAAAjzB,MAAA,qBACA,IAAA4S,YAAA4G,UAAA2Z,GAAA,MAAA,IAAAnzB,MAAA,yBAGAvL,KAAA4+B,QAAAP,EAEAr+B,KAAA6+B,WAAAX,EAEAl+B,KAAA8+B,UAAAR,EAEAt+B,KAAA++B,WAAAR,EAEAv+B,KAAAg/B,SAAAR,EAEAx+B,KAAAi/B,aAAAP,EAQA/+B,cAAAm7B,EAAAtM,EAAAgN,GACA,MAAA5c,EAAA,IAAAxU,aAAAoxB,EAAAp2B,MAEAi5B,EAAAxK,QAAAvkB,YAAAsP,GACAsf,EAAArK,QAAAvkB,YAAAsP,GACAuU,EAAAvU,EAAAoG,YACAsZ,EAAAj0B,KAAAiF,YAAAsP,EAAAuU,GACAoL,EAAA3f,EAAAoG,YACAwZ,EAAA5f,EAAAsG,aAEA,OAAA,IAAAkZ,yBAAAtD,EAAAuD,EAAAH,EAAAI,EAAAC,EAAAC,GAOA7+B,mBAAAif,GAEA,GADAA,EAAAoG,cACA6V,QAAAU,KAAAiB,KAAA,MAAA,IAAAjxB,MAAA,wBAEA,MAAAuvB,EAAAlc,EAAAqe,cACAoB,EAAAxK,QAAAvkB,YAAAsP,GACAsf,EAAArK,QAAAvkB,YAAAsP,GACAuU,EAAAvU,EAAAoG,YACAsZ,EAAAj0B,KAAAiF,YAAAsP,EAAAuU,GACAoL,EAAA3f,EAAAoG,YACAwZ,EAAA5f,EAAAsG,aACAuZ,EAAA7f,EAAAqe,cACA,OAAA,IAAAmB,yBAAAtD,EAAAuD,EAAAH,EAAAI,EAAAC,EAAAC,EAAAC,GAMA9+B,iBAAA27B,GACA,IAAAA,EAAA,MAAA,IAAA/vB,MAAA,mBACA,OAAA,IAAA6yB,yBAAA9C,EAAAR,QAAAjH,QAAAtB,QAAA+I,EAAA+C,QAAAxK,QAAAtB,QAAA+I,EAAA4C,WAAA7zB,KAAAkoB,QAAA+I,EAAAgD,SAAAj0B,KAAAc,UAAAonB,QAAA+I,EAAAnI,gBAAAmI,EAAAiD,UAAAjD,EAAAkD,QAAAlD,EAAAmD,aASA9+B,UAAAif,GAUA,OATAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,gBACAzmB,MAAA+I,UAAA0O,GACA5e,KAAA4+B,QAAA1uB,UAAA0O,GACA5e,KAAA6+B,WAAA3uB,UAAA0O,GACAA,EAAAwG,WAAAplB,KAAA8+B,UAAA9Q,WACAhuB,KAAA8+B,UAAA5uB,UAAA0O,GACAA,EAAAwG,WAAAplB,KAAA++B,YACAngB,EAAA/S,YAAA7L,KAAAg/B,UACApgB,EAAAwc,aAAAp7B,KAAAi/B,cACArgB,EAMAgP,qBACA,OAAAzmB,MAAAymB,eACA5tB,KAAA4+B,QAAAhR,eACA5tB,KAAA6+B,WAAAjR,eACA,EACA5tB,KAAA8+B,UAAAlR,eACA,EACA,EACA,GAIAyQ,aACA,OAAAr+B,KAAA4+B,QAIAV,gBACA,OAAAl+B,KAAA6+B,WAIA1L,oBACA,OAAAnzB,KAAA8+B,UAAA9Q,UAIAsQ,eACA,OAAAt+B,KAAA8+B,UAIAP,gBACA,OAAAv+B,KAAA++B,WAIAP,cACA,OAAAx+B,KAAAg/B,SAIAP,kBACA,OAAAz+B,KAAAi/B,aAGAt/B,WACA,0CAAAK,KAAAi7B,SAAAr4B,sBAAA5C,KAAA4+B,QAAApG,uBAAA,iBAAAx4B,KAAA4+B,QAAApG,uBAAA,cAAAx4B,KAAAi/B,aAAAr8B,cAAA5C,KAAA++B,uBAAA/+B,KAAAg/B,YAMAr/B,UACA,MAAA27B,EAAAn0B,MAAA41B,UAQA,OAPAzB,EAAA+C,OAAAr+B,KAAAq+B,OAAAtB,UACAzB,EAAA4C,UAAAl+B,KAAAk+B,UAAAnB,UACAzB,EAAAnI,cAAA9oB,KAAAc,UAAAvI,SAAA5C,KAAAs+B,SAAAtQ,WACAsN,EAAAgD,SAAAt+B,KAAAs+B,SAAAvB,UACAzB,EAAAiD,UAAAv+B,KAAAu+B,UACAjD,EAAAkD,QAAAx+B,KAAAw+B,QACAlD,EAAAmD,YAAAz+B,KAAAy+B,YAAA77B,WACA04B,EAQA37B,OAAAuiB,GACA,OAAAA,aAAAkc,0BACAp+B,KAAAg7B,QAAA9Y,EAAA8Y,OACAh7B,KAAAi7B,SAAAlgB,GAAAmH,EAAA+Y,WACAj7B,KAAA4+B,QAAA5jB,OAAAkH,EAAA0c,UACA5+B,KAAA6+B,WAAA7jB,OAAAkH,EAAA2c,aACA7+B,KAAA8+B,UAAA9jB,OAAAkH,EAAA4c,YACA9+B,KAAA++B,aAAA7c,EAAA6c,YACA/+B,KAAAg/B,WAAA9c,EAAA8c,UACAh/B,KAAAi/B,aAAAlkB,GAAAmH,EAAA+c,cAOAt/B,iCAAA67B,GACA,IACA,MAAA5c,EAAA,IAAAxU,aAAAoxB,EAAAa,OAEA,OADAzd,EAAAoG,aAEA,KAAAoZ,yBAAAc,UAAAC,iBAAA,CACA,MAAAhM,EAAAvU,EAAAoG,YACAoa,EAAAxgB,EAAAoG,YACAsZ,EAAAj0B,KAAAiF,YAAAsP,EAAAuU,GACA,IAAAkM,EAAAh1B,KAAAiF,YAAAsP,EAAAuU,GAGA,IAAA,IAAAzwB,EAAA,EAAAA,EAAA08B,IAAA18B,EACA28B,EAAAh1B,KAAAi1B,QAAAD,EAAArb,MAAAmP,GAEA,IAAAmL,EAAAtjB,OAAAqkB,GACA,OAAA,EAIA,IAAAnC,eAAA5tB,YAAAsP,GAAA2gB,OAAA,KAAA/D,EAAAgE,oBACA,OAAA,EAEA,MAEA,KAAApB,yBAAAc,UAAAO,cAEA,IAAAvC,eAAA5tB,YAAAsP,GAAA2gB,OAAA,KAAA/D,EAAAgE,oBACA,OAAA,EAIA,IAAAtC,eAAA5tB,YAAAsP,GAAA2gB,OAAA,KAAA/D,EAAAgE,oBACA,OAAA,EAEA,MAEA,KAAApB,yBAAAc,UAAAQ,gBAEA,IAAAxC,eAAA5tB,YAAAsP,GAAA2gB,OAAA,KAAA/D,EAAAgE,oBACA,OAAA,EAEA,MACA,QACA,OAAA,EAIA,OAAA5gB,EAAAiF,UAAAjF,EAAAxS,WAKA,MAAA1L,GACA,OAAA,GAQAf,iCAAA67B,GACA,IACA,MAAA5c,EAAA,IAAAxU,aAAAoxB,EAAAp2B,MAEAyuB,QAAAvkB,YAAAsP,GACAiV,QAAAvkB,YAAAsP,GACA,MAAAuU,EAAAvU,EAAAoG,YACA3a,KAAAiF,YAAAsP,EAAAuU,GACA,MAAAoL,EAAA3f,EAAAoG,YAGA,OAFApG,EAAAsG,aAEA,IAAAqZ,IAKApL,IAAA9oB,KAAAc,UAAA0C,UAIA+Q,EAAAiF,UAAAjF,EAAAxS,YAIA6xB,SAAA0B,0BAAAnE,KACA,MAAA96B,GACA,OAAA,GAQAf,YAAAm7B,GACA,OAAA,IAAAsD,yBAAAtD,EAAA96B,KAAA4+B,QAAA5+B,KAAA6+B,WAAA7+B,KAAA8+B,UAAA9+B,KAAA++B,WAAA/+B,KAAAg/B,SAAAh/B,KAAAi/B,cAUAt/B,wBAAA67B,EAAAhN,EAAAiN,EAAAC,GAAA,GACA,MAAA9c,EAAA,IAAAxU,aAAAoxB,EAAAa,OAEA,IAAAuD,EAAA,EACA,OAFAhhB,EAAAoG,aAGA,KAAAoZ,yBAAAc,UAAAC,iBAAA,CAEA,GAAAn/B,KAAAg/B,SAAAxQ,EACA,MAAA,IAAAqM,QAAA4B,WAIA,MAAAtJ,EAAAvU,EAAAoG,YACAoa,EAAAxgB,EAAAoG,YAEA,IADA3a,KAAAiF,YAAAsP,EAAAuU,GACAnY,OAAAhb,KAAA8+B,WACA,MAAA,IAAAjE,QAAA4B,WAOA,GAHApyB,KAAAiF,YAAAsP,EAAAuU,IAGA+J,eAAA5tB,YAAAsP,GAAAihB,WAAA7/B,KAAA6+B,YACA,MAAA,IAAAhE,QAAA4B,WAGAmD,EAAAvvB,UAAA4B,IAAA,EAAAjS,KAAAi/B,aAAArkB,MAAA,EAAAwkB,EAAAp/B,KAAA++B,YAAA5kB,KAAA,IAEA,MAEA,KAAAikB,yBAAAc,UAAAO,cACA,IAAAvC,eAAA5tB,YAAAsP,GAAAihB,WAAA7/B,KAAA6+B,YACA,MAAA,IAAAhE,QAAA4B,WAGA,IAAAS,eAAA5tB,YAAAsP,GAAAihB,WAAA7/B,KAAA4+B,SACA,MAAA,IAAA/D,QAAA4B,WAGA,MAEA,KAAA2B,yBAAAc,UAAAQ,gBACA,GAAA1/B,KAAAg/B,UAAAxQ,EACA,MAAA,IAAAqM,QAAA4B,WAGA,IAAAS,eAAA5tB,YAAAsP,GAAAihB,WAAA7/B,KAAA4+B,SACA,MAAA,IAAA/D,QAAA4B,WAGA,MAEA,QACA,MAAA,IAAA5B,QAAA4B,WAGA,IAAAf,EAAA,CAEA,GADA17B,KAAAi7B,SAAAtf,MAAA6f,EAAA1X,OAAAnI,MAAA6f,EAAAM,KACA9kB,GAAA4oB,GACA,MAAA,IAAA/E,QAAAmB,aAIA,OAAA70B,MAAA24B,wBAAAtE,EAAAhN,EAAAiN,EAAAC,GAUA/7B,wBAAA67B,EAAAhN,EAAAkN,GAAA,GACA,MAAA,IAAAnwB,MAAA,gCAOA5L,mBAAAyF,GACA,IACA,MAAAwZ,EAAA,IAAAxU,aAAAhF,GAEAi5B,EAAAxK,QAAAvkB,YAAAsP,GACAsf,EAAArK,QAAAvkB,YAAAsP,GACAuU,EAAAvU,EAAAoG,YACAsZ,EAAAj0B,KAAAiF,YAAAsP,EAAAuU,GACAoL,EAAA3f,EAAAoG,YACAwZ,EAAA5f,EAAAsG,aAEA,MAAA,CACAmZ,OAAAA,EAAAtB,UACAmB,UAAAA,EAAAnB,UACA5J,cAAA9oB,KAAAc,UAAAvI,SAAAuwB,GACAmL,SAAAA,EAAAvB,UACAwB,UAAAA,EACAC,QAAAA,GAEA,MAAA99B,GACA,OAAAm6B,QAAA6C,YAAAt4B,IAQAzF,oBAAA08B,GACA,IACA,MAAAzd,EAAA,IAAAxU,aAAAiyB,GACA11B,EAAAiY,EAAAoG,YACA,OAAAre,GACA,KAAAy3B,yBAAAc,UAAAC,iBAAA,CACA,MAAAhM,EAAAvU,EAAAoG,YACAoa,EAAAxgB,EAAAoG,YACAsZ,EAAAj0B,KAAAiF,YAAAsP,EAAAuU,GACAkM,EAAAh1B,KAAAiF,YAAAsP,EAAAuU,GACAwK,EAAAT,eAAA5tB,YAAAsP,GAEA,MAAA,CACAjY,KAAAy3B,yBAAAc,UAAAt8B,SAAA+D,GACAwsB,cAAA9oB,KAAAc,UAAAvI,SAAAuwB,GACAiM,UAAAA,EACAd,SAAAA,EAAAvB,UACAsC,SAAAA,EAAAtC,UACAa,OAAAD,EAAAtJ,UAAAwJ,YAAAd,UACA7E,UAAAyF,EAAAzF,UAAA3G,QACA8C,UAAAsJ,EAAAtJ,UAAA9C,QACAuM,WAAAH,EAAAI,WAAAlR,MAAAlqB,QAGA,KAAAy7B,yBAAAc,UAAAO,cAAA,CACA,MAAA9B,EAAAT,eAAA5tB,YAAAsP,GACAmhB,EAAA7C,eAAA5tB,YAAAsP,GACA,MAAA,CACAjY,KAAAy3B,yBAAAc,UAAAt8B,SAAA+D,GACAi3B,OAAAD,EAAAtJ,UAAAwJ,YAAAd,UACA7E,UAAAyF,EAAAzF,UAAA3G,QACA8C,UAAAsJ,EAAAtJ,UAAA9C,QACAuM,WAAAH,EAAAI,WAAAlR,MAAAlqB,OACAq9B,QAAAD,EAAA1L,UAAAwJ,YAAAd,UACAkD,iBAAAF,EAAA7H,UAAA3G,QACA2O,iBAAAH,EAAA1L,UAAA9C,QACA4O,kBAAAJ,EAAAhC,WAAAlR,MAAAlqB,QAGA,KAAAy7B,yBAAAc,UAAAQ,gBAAA,CACA,MAAAK,EAAA7C,eAAA5tB,YAAAsP,GACA,MAAA,CACAjY,KAAAy3B,yBAAAc,UAAAt8B,SAAA+D,GACAq5B,QAAAD,EAAA1L,UAAAwJ,YAAAd,UACAkD,iBAAAF,EAAA7H,UAAA3G,QACA2O,iBAAAH,EAAA1L,UAAA9C,QACA4O,kBAAAJ,EAAAhC,WAAAlR,MAAAlqB,QAGA,QACA,OAAA,GAEA,MAAAjC,GACA,OAAAm6B,QAAAmD,aAAA3B,KAKA+B,yBAAAc,UAAA,CACAC,iBAAA,EACAM,cAAA,EACAC,gBAAA,GAOAtB,yBAAAc,UAAAt8B,SAAA,SAAAw9B,GACA,OAAAA,GACA,KAAAhC,yBAAAc,UAAAC,iBAAA,MAAA,mBACA,KAAAf,yBAAAc,UAAAO,cAAA,MAAA,gBACA,KAAArB,yBAAAc,UAAAQ,gBAAA,MAAA,kBAEA,MAAA,IAAAn0B,MAAA,uBAGAsvB,QAAAK,SAAAjzB,IAAA4yB,QAAAU,KAAAiB,KAAA4B,0BACA9+B,MAAAQ,SAAAs+B,0BCleA,MAAAiC,wBAAApC,SASAt+B,YAAAm7B,EAAA,EAAAwF,EAAAzM,QAAAT,KAAAmN,EAAA,EAAAC,EAAA,EAAAC,EAAA3F,EAAA4F,EAAA5F,GACA3zB,MAAA0zB,QAAAU,KAAAgB,QAAAzB,GACA,MAAA6F,EAAA,IAAAtwB,UAAAowB,GACAG,EAAA,IAAAvwB,UAAAqwB,GACA,KAAAJ,aAAAzM,SAAA,MAAA,IAAAtoB,MAAA,2BACA,IAAA4S,YAAAwgB,SAAA4B,GAAA,MAAA,IAAAh1B,MAAA,0BACA,IAAA4S,YAAAwgB,SAAA6B,GAAA,MAAA,IAAAj1B,MAAA,+BACA,IAAA4S,YAAA4G,UAAA4b,GAAA,MAAA,IAAAp1B,MAAA,+BACA,IAAA4S,YAAA4G,UAAA6b,GAAA,MAAA,IAAAr1B,MAAA,gCAGAvL,KAAA6gC,OAAAP,EAEAtgC,KAAA8gC,cAAAP,EAEAvgC,KAAA+gC,mBAAAP,EAEAxgC,KAAAghC,mBAAAL,EAEA3gC,KAAAihC,oBAAAL,EAQAjhC,cAAAm7B,EAAAtM,EAAAgN,GAEA,IAAA+E,EAAAC,EAAAC,EAAAC,EACA,MAAA9hB,EAAA,IAAAxU,aAAAoxB,EAAAp2B,MACAk7B,EAAAzM,QAAAvkB,YAAAsP,GAEA,OADA8hB,EAAAlF,EAAA1X,MACA0X,EAAAp2B,KAAAzC,QACA,KAAAkxB,QAAAyE,gBAAA,EAEAiI,EAAA,EACAC,EAAA5hB,EAAAsG,aACAub,EAAAC,EACA,MACA,KAAA7M,QAAAyE,gBAAA,GACAiI,EAAA3hB,EAAAsG,aACAsb,EAAA5hB,EAAAsG,aACAub,EAAA7hB,EAAAqe,cACA,MACA,KAAApJ,QAAAyE,gBAAA,GAEAiI,EAAA3hB,EAAAsG,aACAsb,EAAA5hB,EAAAsG,aACAub,EAAA7hB,EAAAqe,cACAyD,EAAA9hB,EAAAqe,cACA,MACA,QACA,MAAA,IAAA1xB,MAAA,4BAEA,OAAA,IAAA80B,gBAAAvF,EAAAwF,EAAAC,EAAAC,EAAAC,EAAAC,GAOA/gC,mBAAAif,GAEA,GADAA,EAAAoG,cACA6V,QAAAU,KAAAgB,QAAA,MAAA,IAAAhxB,MAAA,wBAEA,MAAAuvB,EAAAlc,EAAAqe,cACAqD,EAAAzM,QAAAvkB,YAAAsP,GACA2hB,EAAA3hB,EAAAsG,aACAsb,EAAA5hB,EAAAsG,aACAub,EAAA7hB,EAAAqe,cACAyD,EAAA9hB,EAAAqe,cACA,OAAA,IAAAoD,gBAAAvF,EAAAwF,EAAAC,EAAAC,EAAAC,EAAAC,GAMA/gC,iBAAA27B,GACA,IAAAA,EAAA,MAAA,IAAA/vB,MAAA,mBACA,OAAA,IAAA80B,gBAAA/E,EAAAR,QAAAjH,QAAAtB,QAAA+I,EAAAgF,OAAAhF,EAAAiF,aAAAjF,EAAAkF,kBAAAlF,EAAAmF,kBAAAnF,EAAAoF,oBAQA/gC,UAAAif,GAQA,OAPAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,gBACAzmB,MAAA+I,UAAA0O,GACA5e,KAAA6gC,OAAA3wB,UAAA0O,GACAA,EAAA/S,YAAA7L,KAAA8gC,eACAliB,EAAA/S,YAAA7L,KAAA+gC,oBACAniB,EAAAwc,aAAAp7B,KAAAghC,oBACApiB,EAAAwc,aAAAp7B,KAAAihC,qBACAriB,EAMAgP,qBACA,OAAAzmB,MAAAymB,eACA5tB,KAAA6gC,OAAAjT,eACA,EACA,EACA,GACA,GAIA0S,YACA,OAAAtgC,KAAA6gC,OAIAN,mBACA,OAAAvgC,KAAA8gC,cAIAN,wBACA,OAAAxgC,KAAA+gC,mBAIAN,wBACA,OAAAzgC,KAAAghC,mBAIAN,yBACA,OAAA1gC,KAAAihC,oBAGAthC,WACA,gCAAAK,KAAAi7B,SAAAr4B,qBAAA5C,KAAA6gC,OAAArI,0BAMA74B,UACA,MAAA27B,EAAAn0B,MAAA41B,UAMA,OALAzB,EAAAgF,MAAAtgC,KAAAsgC,MAAAvD,UACAzB,EAAAiF,aAAAvgC,KAAAugC,aACAjF,EAAAkF,kBAAAxgC,KAAAwgC,kBACAlF,EAAAmF,kBAAAzgC,KAAAygC,kBAAA79B,WACA04B,EAAAoF,mBAAA1gC,KAAA0gC,mBAAA99B,WACA04B,EAQA37B,OAAAuiB,GACA,OAAAA,aAAAme,iBACArgC,KAAAg7B,QAAA9Y,EAAA8Y,OACAh7B,KAAAi7B,SAAAlgB,GAAAmH,EAAA+Y,WACAj7B,KAAA6gC,OAAA7lB,OAAAkH,EAAA2e,SACA7gC,KAAA8gC,gBAAA5e,EAAA4e,eACA9gC,KAAA+gC,qBAAA7e,EAAA6e,oBACA/gC,KAAAghC,mBAAAjmB,GAAAmH,EAAA8e,qBACAhhC,KAAAihC,oBAAAlmB,GAAAmH,EAAA+e,qBAOAthC,iCAAA67B,GACA,MAAA5c,EAAA,IAAAxU,aAAAoxB,EAAAa,OAEA,QAAAa,eAAA5tB,YAAAsP,GAAA2gB,OAAA,KAAA/D,EAAAgE,qBAIA5gB,EAAAiF,UAAAjF,EAAAxS,WAWAzM,iCAAA67B,GACA,OAAAA,EAAAp2B,KAAAzC,QACA,KAAAkxB,QAAAyE,gBAAA,EACA,KAAAzE,QAAAyE,gBAAA,GACA,KAAAzE,QAAAyE,gBAAA,GACA,OAAA2F,SAAA0B,0BAAAnE,GACA,QACA,OAAA,GAQA77B,YAAAm7B,GACA,OAAA,IAAAuF,gBAAAvF,EAAA96B,KAAA6gC,OAAA7gC,KAAA8gC,cAAA9gC,KAAA+gC,mBAAA/gC,KAAAghC,mBAAAhhC,KAAAihC,qBAUAthC,wBAAA67B,EAAAhN,EAAAiN,EAAAC,GAAA,GACA,IAAAA,EAAA,CACA,MAAAkE,EAAA5/B,KAAAkhC,UAAA1S,GAEA,GADAxuB,KAAAi7B,SAAAtf,MAAA6f,EAAA1X,OAAAnI,MAAA6f,EAAAM,KACA9kB,GAAA4oB,GACA,MAAA,IAAA/E,QAAAmB,aAGA,MAAApd,EAAA,IAAAxU,aAAAoxB,EAAAa,OACA,IAAAa,eAAA5tB,YAAAsP,GAAAihB,WAAA7/B,KAAA6gC,QACA,MAAA,IAAAhG,QAAA4B,WAGA,OAAAt1B,MAAA24B,wBAAAtE,EAAAhN,EAAAiN,EAAAC,GASA/7B,wBAAA67B,EAAAhN,EAAAkN,GAAA,GACA,MAAA,IAAAnwB,MAAA,gCAOA5L,UAAA6uB,GACA,OAAAxuB,KAAA+gC,oBAAA/gC,KAAAghC,mBAAA9pB,GAAA,GACA7G,UAAA4B,IAAA,EAAAjS,KAAAihC,oBAAAtlB,MAAA3b,KAAAghC,mBAAApmB,MAAAvP,KAAAoF,OAAA+d,EAAAxuB,KAAA8gC,eAAA9gC,KAAA+gC,uBACA,IAAA1wB,UAAA,GAQA1Q,mBAAAyF,GACA,IACA,IAAAm7B,EAAAC,EAAAC,EAAAC,EACA,MAAA9hB,EAAA,IAAAxU,aAAAhF,GACAk7B,EAAAzM,QAAAvkB,YAAAsP,GACA,OAAAxZ,EAAAzC,QACA,KAAAkxB,QAAAyE,gBAAA,EACAiI,EAAA,EACAC,EAAA5hB,EAAAsG,aACA,MACA,KAAA2O,QAAAyE,gBAAA,GACAiI,EAAA3hB,EAAAsG,aACAsb,EAAA5hB,EAAAsG,aACAub,EAAA7hB,EAAAqe,cAAAr6B,WACA,MACA,KAAAixB,QAAAyE,gBAAA,GACAiI,EAAA3hB,EAAAsG,aACAsb,EAAA5hB,EAAAsG,aACAub,EAAA7hB,EAAAqe,cAAAr6B,WACA89B,EAAA9hB,EAAAqe,cAAAr6B,WACA,MACA,QACA,MAAA,IAAA2I,MAAA,4BAEA,MAAA,CACA+0B,MAAAA,EAAAvD,UACAwD,aAAAA,EACAC,kBAAAA,EACAC,kBAAAA,EACAC,mBAAAA,GAEA,MAAAhgC,GACA,OAAAm6B,QAAA6C,YAAAt4B,IAQAzF,oBAAA08B,GACA,IACA,MAAAsB,EAAAT,eAAA5tB,YAAA,IAAAlF,aAAAiyB,IACA,MAAA,CACAnE,UAAAyF,EAAAzF,UAAA3G,QACA8C,UAAAsJ,EAAAtJ,UAAA9C,QACAqM,OAAAD,EAAAtJ,UAAAwJ,YAAAd,UACAe,WAAAH,EAAAI,WAAAlR,MAAAlqB,QAEA,MAAAjC,GACA,OAAAm6B,QAAAmD,aAAA3B,KAKAxB,QAAAK,SAAAjzB,IAAA4yB,QAAAU,KAAAgB,QAAA8D,iBACA/gC,MAAAQ,SAAAugC,iBCnUA,MAAAc,YAYAxhC,YAAAyhC,EAAArxB,EAAAE,EAAAoxB,EAAAzY,EAAAuG,EAAAmS,EAAAza,EAAA0a,EAAAJ,YAAAK,iBACA,IAAArjB,YAAAsjB,SAAAF,GAAA,MAAA,IAAAh2B,MAAA,qBACA,IAAAlB,KAAAq3B,OAAAN,GAAA,MAAA,IAAA71B,MAAA,sBACA,IAAAlB,KAAAq3B,OAAA3xB,GAAA,MAAA,IAAAxE,MAAA,2BACA,IAAAlB,KAAAq3B,OAAAzxB,GAAA,MAAA,IAAA1E,MAAA,sBACA,IAAAlB,KAAAq3B,OAAAL,GAAA,MAAA,IAAA91B,MAAA,0BACA,IAAA4S,YAAAwgB,SAAA/V,KAAA+Y,WAAAC,eAAAhZ,GAAA,MAAA,IAAArd,MAAA,mBACA,IAAA4S,YAAAwgB,SAAAxP,GAAA,MAAA,IAAA5jB,MAAA,kBACA,IAAA4S,YAAAwgB,SAAA2C,GAAA,MAAA,IAAA/1B,MAAA,uBACA,IAAA4S,YAAAwgB,SAAA9X,GAAA,MAAA,IAAAtb,MAAA,mBAGAvL,KAAA6hC,SAAAN,EAEAvhC,KAAA8hC,UAAAV,EAEAphC,KAAA+hC,eAAAhyB,EAEA/P,KAAAgiC,UAAA/xB,EAEAjQ,KAAAiiC,cAAAZ,EAEArhC,KAAAkiC,OAAAtZ,EAEA5oB,KAAAmiC,QAAAhT,EAEAnvB,KAAAoiC,WAAAd,EAEAthC,KAAAqiC,OAAAxb,EAOAlnB,mBAAAif,GACA,MAAA2iB,EAAA3iB,EAAAqG,aACA,IAAAkc,YAAAmB,mBAAAC,SAAAhB,GAAA,MAAA,IAAAh2B,mCAAAg2B,KACA,MAAAH,EAAA/2B,KAAAiF,YAAAsP,GACA7O,EAAA1F,KAAAiF,YAAAsP,GACA3O,EAAA5F,KAAAiF,YAAAsP,GACAyiB,EAAAh3B,KAAAiF,YAAAsP,GACAgK,EAAAhK,EAAAsG,aACAiK,EAAAvQ,EAAAsG,aACAoc,EAAA1iB,EAAAsG,aACA2B,EAAAjI,EAAAsG,aACA,OAAA,IAAAic,YAAAC,EAAArxB,EAAAE,EAAAoxB,EAAAzY,EAAAuG,EAAAmS,EAAAza,EAAA0a,GAOA5hC,UAAAif,GAWA,OAVAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAvI,YAAArlB,KAAA6hC,UACA7hC,KAAA8hC,UAAA5xB,UAAA0O,GACA5e,KAAA+hC,eAAA7xB,UAAA0O,GACA5e,KAAAgiC,UAAA9xB,UAAA0O,GACA5e,KAAAiiC,cAAA/xB,UAAA0O,GACAA,EAAA/S,YAAA7L,KAAAkiC,QACAtjB,EAAA/S,YAAA7L,KAAAmiC,SACAvjB,EAAA/S,YAAA7L,KAAAoiC,YACAxjB,EAAA/S,YAAA7L,KAAAqiC,QACAzjB,EAIAgP,qBACA,OAAA,EACA5tB,KAAA8hC,UAAAlU,eACA5tB,KAAA+hC,eAAAnU,eACA5tB,KAAAgiC,UAAApU,eACA5tB,KAAAiiC,cAAArU,eACA,EACA,EACA,EACA,EAOAjuB,wBAAAif,GACA,MAAAtT,QAAAtL,KAAAsL,IAAAsT,GACA,OAAA+iB,WAAAa,cAAAl3B,EAAAtL,KAAAkvB,QAOAvvB,uBAAA8iC,GAEA,GAAAziC,KAAAmvB,SAAAsT,EAAAtT,OAAA,EACA,OAAA,EAIA,GAAAnvB,KAAAshC,UAAAmB,EAAAnB,UACA,OAAA,EAIA,MAAAF,EAAAqB,EAAA/zB,OACA,QAAA1O,KAAAohC,SAAApmB,OAAAomB,GAYAzhC,KAAAif,GAEA,OADA5e,KAAAosB,MAAApsB,KAAAosB,OAAA/hB,KAAAiiB,MAAAtsB,KAAAkQ,UAAA0O,IACA5e,KAAAosB,MAOAzsB,UAAAif,GAEA,OADA5e,KAAA0iC,KAAA1iC,KAAA0iC,YAAAr4B,KAAAs4B,KAAA3iC,KAAAkQ,UAAA0O,IACA5e,KAAA0iC,KAOA/iC,OAAAuiB,GACA,OAAAA,aAAAif,aACAnhC,KAAA8hC,UAAA9mB,OAAAkH,EAAAkf,WACAphC,KAAA+hC,eAAA/mB,OAAAkH,EAAAnS,gBACA/P,KAAAgiC,UAAAhnB,OAAAkH,EAAAjS,WACAjQ,KAAAiiC,cAAAjnB,OAAAkH,EAAAmf,eACArhC,KAAAkiC,SAAAhgB,EAAA0G,OACA5oB,KAAAmiC,UAAAjgB,EAAAiN,QACAnvB,KAAAoiC,aAAAlgB,EAAAof,WACAthC,KAAAqiC,SAAAngB,EAAA2E,MAMAlnB,WACA,MAAA,2BACAK,KAAA8hC,+BACA9hC,KAAA+hC,+BACA/hC,KAAAgiC,8BACAhiC,KAAAiiC,2BACAjiC,KAAAkiC,OAAAt/B,SAAA,kBACA5C,KAAAmiC,yBACAniC,KAAAoiC,wBACApiC,KAAAqiC,SACA,IAIAd,cACA,OAAAvhC,KAAA6hC,SAIAT,eACA,OAAAphC,KAAA8hC,UAIA/xB,oBACA,OAAA/P,KAAA+hC,eAIA9xB,eACA,OAAAjQ,KAAAgiC,UAIAX,mBACA,OAAArhC,KAAAiiC,cAIArZ,YACA,OAAA5oB,KAAAkiC,OAIAhT,aACA,OAAAyS,WAAAiB,gBAAA5iC,KAAAkiC,QAIAW,iBACA,OAAAlB,WAAAmB,oBAAA9iC,KAAAkiC,QAIA/S,aACA,OAAAnvB,KAAAmiC,QAIAb,gBACA,OAAAthC,KAAAoiC,WAIAvb,YACA,OAAA7mB,KAAAqiC,OAMAxb,UAAA1V,GACAnR,KAAAqiC,OAAAlxB,EACAnR,KAAAosB,MAAA,KACApsB,KAAA0iC,KAAA,MAGAvB,YAAA4B,QAAA,CACAC,GAAA,GAEA7B,YAAAK,gBAAAL,YAAA4B,QAAAC,GACA7B,YAAAmB,mBAAA,CACAnB,YAAA4B,QAAAC,IAEA7B,YAAA7I,gBAAA,IACAh5B,MAAAQ,SAAAqhC,aCxPA,MAAA8B,eAOAtjC,iBAAAiP,EAAAwyB,GACA,MAAAvT,EAAAjf,EAAAjM,OACAugC,EAAA73B,KAAAG,KAAAqiB,EAAA,GACAsV,EAAA,IAAAx1B,WAAAu1B,GAEA,IAAAE,EAAAhC,EACA,MAAApM,EAAA,GACA,IAAA,IAAAtyB,EAAA,EAAAA,EAAAmrB,EAAAnrB,IAAA,CACA,MAAAgM,EAAAE,EAAAlM,GACAgM,EAAAsM,OAAAooB,GAIAD,EAAA93B,KAAAoF,MAAA/N,EAAA,KAAA,MAAAA,EAAA,GAHAsyB,EAAA3rB,KAAAqF,GACA00B,EAAA10B,GAMA,MAAA,CAAAy0B,WAAAA,EAAAnO,WAAAA,GASAr1B,YAAAiP,EAAAwyB,EAAA+B,EAAAnO,GACA,IAAA/xB,MAAAiP,QAAAtD,KAAAuP,YAAA8H,QAAArX,EAAAjM,SACAiM,EAAAke,KAAAC,KAAAA,aAAA1iB,OAAA,MAAA,IAAAkB,MAAA,oBACA,IAAA43B,GAAAnO,MAAAmO,IAAAnO,GAAA,MAAA,IAAAzpB,MAAA,mCACA,IAAA61B,IAAA+B,EAAA,MAAA,IAAA53B,MAAA,qDAEA43B,KACAA,WAAAA,EAAAnO,WAAAA,GAAAiO,eAAAhV,UAAArf,EAAAwyB,IAIAphC,KAAAqjC,QAAAz0B,EAEA5O,KAAAsjC,YAAAH,EAEAnjC,KAAAujC,YAAAvO,EAQAr1B,mBAAAif,EAAAwiB,GACA,MAAAvT,EAAAjP,EAAAoG,YACAke,EAAA73B,KAAAG,KAAAqiB,EAAA,GACAsV,EAAAvkB,EAAA8G,KAAAwd,GAEA,IAAAx0B,EAAA0yB,EACA,MAAAxyB,EAAA,GACAomB,EAAA,GACA,IAAA,IAAAtyB,EAAA,EAAAA,EAAAmrB,EAAAnrB,IAAA,CACA,IAAAygC,EAAA93B,KAAAoF,MAAA/N,EAAA,IAAA,MAAAA,EAAA,KAEAgM,EAAArE,KAAAiF,YAAAsP,GACAoW,EAAA3rB,KAAAqF,IAEAE,EAAAvF,KAAAqF,GAGA,OAAA,IAAAu0B,eAAAr0B,EAAAwyB,EAAA+B,EAAAnO,GAOAr1B,UAAAif,IACAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAxI,WAAAplB,KAAAqjC,QAAA1gC,QACAic,EAAAhT,MAAA5L,KAAAsjC,aACA,IAAA,MAAA50B,KAAA1O,KAAAujC,YACA70B,EAAAwB,UAAA0O,GAEA,OAAAA,EAMAgP,qBACA,OAAA,EACA5tB,KAAAsjC,YAAA3gC,OACA3C,KAAAujC,YAAApd,OAAA,CAAA+H,EAAAxf,IAAAwf,EAAAxf,EAAAkf,eAAA,GAOAjuB,OAAAuiB,GACA,OAAAA,aAAA+gB,gBACAjjC,KAAAqjC,QAAA1gC,SAAAuf,EAAAmhB,QAAA1gC,QACA3C,KAAAqjC,QAAAlV,MAAA,CAAAzf,EAAAhM,IAAAgM,EAAAsM,OAAAkH,EAAAtT,OAAAlM,KAMA/C,OAIA,OAHAK,KAAAosB,QACApsB,KAAAosB,MAAAH,WAAAuX,YAAA,CAAAxjC,KAAAsjC,YAAAl0B,cAAAC,gBAAArP,KAAAujC,eAEAvjC,KAAAosB,MAMAxd,aACA,OAAA5O,KAAAqjC,QAMA1gC,aACA,OAAA3C,KAAAqjC,QAAA1gC,QAGArD,MAAAQ,SAAAmjC,gBCrIA,MAAAQ,UAKA9jC,uBAAA+jC,GACA,OAAA7P,QAAAyE,gBACA,EACAoL,EAAAt3B,WACA,EACA,EASAzM,YAAAgkC,EAAAj0B,EAAAg0B,EAAA,IAAA/1B,WAAA,GAAAi2B,EAAA,IACA,KAAAD,aAAA9P,SAAA,MAAA,IAAAtoB,MAAA,uBACA,IAAAtI,MAAAiP,QAAAxC,IAAAA,EAAAod,KAAAC,KAAAA,aAAAsQ,cAAA,MAAA,IAAA9xB,MAAA,0BACA,KAAAm4B,aAAA/1B,YAAAwQ,YAAA8H,QAAAyd,EAAAt3B,aAAA,MAAA,IAAAb,MAAA,uBAGAvL,KAAA6jC,WAAAF,EAEA3jC,KAAA8jC,WAAAJ,EAEA1jC,KAAA+jC,cAAAr0B,EAEA1P,KAAAgkC,gBAAAJ,EAEA5jC,KAAAosB,MAAA,KAOAzsB,mBAAAif,GACA,MAAA+kB,EAAA9P,QAAAvkB,YAAAsP,GACAqlB,EAAArlB,EAAAoG,YACA0e,EAAA9kB,EAAA8G,KAAAue,GACAC,EAAAtlB,EAAAqG,aACAvV,EAAA,IAAAzM,MAAAihC,GACA,IAAA,IAAAxhC,EAAA,EAAAA,EAAAwhC,EAAAxhC,IACAgN,EAAAhN,GAAA26B,YAAA/tB,YAAAsP,GAEA,MAAAulB,EAAAvlB,EAAAqG,aACA2e,EAAA,GACA,IAAA,IAAAlhC,EAAA,EAAAA,EAAAyhC,EAAAzhC,IACAkhC,EAAAv6B,KAAAqzB,cAAAptB,YAAAsP,IAEA,OAAA,IAAA6kB,UAAAE,EAAAj0B,EAAAg0B,EAAAE,GAOAjkC,UAAAif,GACAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,gBACA5tB,KAAA6jC,WAAA3zB,UAAA0O,GACAA,EAAAwG,WAAAplB,KAAA8jC,WAAA13B,YACAwS,EAAAhT,MAAA5L,KAAA8jC,YACAllB,EAAAyG,YAAArlB,KAAA+jC,cAAAphC,QACA,IAAA,MAAAyhC,KAAApkC,KAAA+jC,cACAK,EAAAl0B,UAAA0O,GAEAA,EAAAyG,YAAArlB,KAAAgkC,gBAAArhC,QACA,IAAA,MAAAyjB,KAAApmB,KAAAgkC,gBACA5d,EAAAlW,UAAA0O,GAEA,OAAAA,EAMAgP,qBACA,IAAA5oB,EAAAhF,KAAA6jC,WAAAjW,eACA,EACA5tB,KAAA8jC,WAAA13B,WACA,EACA,EACA,IAAA,MAAAg4B,KAAApkC,KAAA+jC,cACA/+B,GAAAo/B,EAAAxW,eAGA,OADA5oB,GAAAhF,KAAAgkC,gBAAA7d,OAAA,CAAA+H,EAAA9H,IAAA8H,EAAA9H,EAAAwH,eAAA,GAOAjuB,SAEA,IAAA0kC,EAAA,KACA,IAAA,MAAAD,KAAApkC,KAAA+jC,cAAA,CAEA,GAAAM,GAAAA,EAAAC,kBAAAF,IAAA,EAEA,OADAlkC,IAAA4D,EAAA2/B,UAAA,8CACA,EAKA,GAHAY,EAAAD,GAGAA,EAAA7E,SAEA,OADAr/B,IAAA4D,EAAA2/B,UAAA,wCACA,EAIA,IAAAc,EAAA,KACA,IAAA,MAAAne,KAAApmB,KAAAgkC,gBAAA,CAEA,GAAAO,GAAAA,EAAA9yB,QAAA2U,IAAA,EAEA,OADAlmB,IAAA4D,EAAA2/B,UAAA,iDACA,EAKA,GAHAc,EAAAne,GAGAA,EAAAuW,QAAA6H,eAEA,OADAtkC,IAAA4D,EAAA2/B,UAAA,2CACA,EAKA,OAAA,EAMA9jC,iBACA,MAAA,CAAAK,KAAA6jC,WAAA7jC,KAAA8jC,cAAA9jC,KAAA+jC,iBAAA/jC,KAAA4jC,gBAMAjkC,OAIA,OAHAK,KAAAosB,QACApsB,KAAAosB,MAAAH,WAAAuX,YAAAxjC,KAAAykC,mBAEAzkC,KAAAosB,MAOAzsB,OAAAuiB,GACA,OAAAA,aAAAuhB,WACAzjC,KAAA6jC,WAAA7oB,OAAAkH,EAAAyhB,YACAh5B,YAAAqQ,OAAAhb,KAAA8jC,WAAA5hB,EAAAwhB,YACA1jC,KAAA+jC,cAAAphC,SAAAuf,EAAAxS,aAAA/M,QACA3C,KAAA+jC,cAAA5V,MAAA,CAAAiW,EAAA1hC,IAAA0hC,EAAAppB,OAAAkH,EAAAxS,aAAAhN,KAMA/C,eACA,MAAA+kC,EAAA,CAAA1kC,KAAA6jC,YACA,IAAA,MAAAO,KAAApkC,KAAA+jC,cACAW,EAAAr7B,KAAA+6B,EAAA/F,OAAA+F,EAAAlG,WAEA,OAAAwG,EAIAhB,gBACA,OAAA1jC,KAAA8jC,WAIAH,gBACA,OAAA3jC,KAAA6jC,WAIAn0B,mBACA,OAAA1P,KAAA+jC,cAIAY,uBACA,OAAA3kC,KAAA+jC,cAAAphC,OAIAihC,qBACA,OAAA5jC,KAAAgkC,iBAIA1kC,MAAAQ,SAAA2jC,WCxMA,MAAA9B,WAKAhiC,uBAAA6mB,GACA,OAAA,IAAAnW,UAAA,SAAAmW,GAAA5L,MAAA,IAAAvK,UAAA,GAAA/E,IAAA,EAAAD,KAAA4G,KAAAuU,GAAA,IAAA,EAAA,KAOA7mB,uBAAAuvB,GACA,IAAAA,EAAAjU,YAAAiU,EAAAzrB,QAAA,MAAA,IAAA8H,MAAA,kBAGA,IAAAvG,EAAAqG,KAAA4G,IAAA5G,KAAAG,KAAAH,KAAAu5B,KAAA1V,EAAAlR,YAAA,GAAA,GAcA,OAbAkR,EAAA7jB,KAAAC,IAAA,EAAA,GAAAtG,EAAA,KAIA,KAAAA,GAAA,GACAA,KAQAA,GAAA,KAAAkqB,EAAA7jB,KAAAC,IAAA,EAAA,EAAAD,KAAA4G,IAAAjN,EAAA,EAAA,IAAA,UAOArF,uBAAAuvB,GAEA,OAAA7jB,KAAAG,KAAAH,KAAAu5B,KAAA1V,EAAAlR,aAOAre,sBAAAuvB,GACA,OAAAyS,WAAAkD,gBAAArd,OAAAC,kBAAAka,WAAAkD,gBAAA3V,GAOAvvB,2BAAA6mB,GACA,OAAAgB,OAAAC,iBAAA7U,IAAA+uB,WAAAiB,gBAAApc,IAOA7mB,2BAAAkjC,GACA,OAAAlB,WAAAmD,gBAAAnD,WAAAoD,mBAAAlC,IAOAljC,0BAAAkjC,GACA,OAAArb,OAAAC,iBAAA7U,IAAAiwB,GAOAljC,0BAAAuvB,GACA,OAAA1H,OAAAC,iBAAA7U,IAAAsc,GAOAvvB,oBAAA+O,GACA,OAAA,IAAA2B,UAAA3B,EAAA6iB,QAAA,IAOA5xB,sBAAA+O,GACA,OAAAizB,WAAAqD,mBAAArD,WAAAsD,aAAAv2B,IAOA/O,oBAAA+O,GACA,OAAAizB,WAAAuD,eAAAvD,WAAAsD,aAAAv2B,IAQA/O,qBAAA+O,EAAAwgB,GACA,OAAA,IAAA7e,UAAA3B,EAAA6iB,QAAA,IAAAhW,IAAA2T,GAQAvvB,sBAAA6mB,GACA,OAAAmb,WAAAwD,cAAAxD,WAAAiB,gBAAApc,IAOA7mB,qBAAAuvB,GACA,OAAA,OAAAA,GAAAA,EAAA9T,IAAA,IAAA8T,EAAA3T,IAAAiM,OAAAC,kBASA9nB,qBAAAylC,EAAAC,EAAAC,GACA,MAAAC,EAAA/d,OAAAge,sBAAAJ,EAAAjW,QACApD,OAAA0Z,KACAL,EAAAjW,OAAAkW,EAAAlW,SAAAoW,GACAH,EAAAjW,QAAAoW,GAAA,IAAAF,EAAAlW,sCACAoW,kBAEA,IAAAG,EAAAN,EAAA9D,UAAA+D,EAAA/D,UAIA8D,EAAAjW,QAAAoW,IACAG,IAAAH,EAAAH,EAAAjW,OAAA,GAAA3H,OAAAsH,mBACAwW,EAAAA,EAAAzpB,KAAA0pB,EAAAH,EAAAjW,OAAA,IAKA,IAAAwW,EAAAD,GADAH,EAAA/d,OAAAiJ,UAAA2U,EAAAjW,SAGAiW,EAAAjW,QAAA3H,OAAA8I,qCAEAqV,EAAAt6B,KAAA4G,IAAA0zB,EAAA,EAAAne,OAAAqJ,yCACA8U,EAAAt6B,KAAA2G,IAAA2zB,EAAA,EAAAne,OAAAsJ,0CACAsU,EAAAjW,QAAA3H,OAAAyI,yCAEA0V,EAAAt6B,KAAA4G,IAAA0zB,EAAA,EAAAne,OAAAmJ,sCACAgV,EAAAt6B,KAAA2G,IAAA2zB,EAAA,EAAAne,OAAAoJ,wCAIA+U,EAAAt6B,KAAA4G,IAAA0zB,EAAA,EAAAne,OAAAkJ,kCACAiV,EAAAt6B,KAAA2G,IAAA2zB,EAAAne,OAAAkJ,mCAIA,MAAAkV,EAAAN,EAAA1yB,IAAA2yB,GAEA,IAAAM,EADAlE,WAAAoD,mBAAAa,GACAhrB,MAAA+qB,GAIAE,EAAAx1B,UAAA2B,IAAA6zB,EAAAre,OAAAC,kBACAoe,EAAAx1B,UAAA4B,IAAA4zB,EAAA,GAGA,MAAAjd,EAAA+Y,WAAAmD,gBAAAe,GACA,OAAAlE,WAAAiB,gBAAAha,IAGAtpB,MAAAQ,SAAA6hC,YC7LA,MAAAnyB,MAMA7P,YAAAmQ,EAAAE,EAAAP,GACA,KAAAK,aAAAqxB,aAAA,MAAA,IAAA51B,MAAA,oBACA,KAAAyE,aAAAizB,gBAAA,MAAA,IAAA13B,MAAA,uBACA,GAAAkE,KAAAA,aAAAg0B,WAAA,MAAA,IAAAl4B,MAAA,kBAGAvL,KAAA8lC,QAAAh2B,EAEA9P,KAAA+lC,WAAA/1B,EAEAhQ,KAAAgmC,MAAAv2B,EAOA9P,mBAAAif,GACA,MAAA9O,EAAAqxB,YAAA7xB,YAAAsP,GACA5O,EAAAizB,eAAA3zB,YAAAsP,EAAA9O,EAAAsxB,UAEA,IAAA3xB,OAAApM,EAMA,OALAub,EAAAoG,cAEAvV,EAAAg0B,UAAAn0B,YAAAsP,IAGA,IAAApP,MAAAM,EAAAE,EAAAP,GAOA9P,UAAAif,GAYA,OAXAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,gBACA5tB,KAAA8lC,QAAA51B,UAAA0O,GACA5e,KAAA+lC,WAAA71B,UAAA0O,GAEA5e,KAAAgmC,OACApnB,EAAAwG,WAAA,GACAplB,KAAAgmC,MAAA91B,UAAA0O,IAEAA,EAAAwG,WAAA,GAGAxG,EAIAgP,qBACA,OAAA5tB,KAAA8lC,QAAAlY,eACA5tB,KAAA+lC,WAAAnY,eACA,GACA5tB,KAAAgmC,MAAAhmC,KAAAgmC,MAAApY,eAAA,GAOAjuB,aAAA6wB,GACA,QAAAntB,IAAArD,KAAA2P,OACA,GAAA3P,KAAAimC,WAAAjmC,KAAAyP,KAAAC,aAAA/M,OAAA,MAAAqB,QAAA2B,gBAEA3F,KAAA2P,aAAA3P,KAAA6P,QAAA2gB,EAAA0V,WACA,CACA,MAAAn5B,EAAA/M,KAAAyP,KAAAC,aAAAgR,IAAA3c,GAAAA,EAAA4L,QACAzL,QAAA+H,aAAAC,oBACA0D,MAAAA,EAAAtE,IAAAA,EAAAyE,cAAAA,EAAAE,SAAAA,SAAA/L,EAAAiiC,YAAAnmC,KAAAkQ,YACAnD,EAAAyjB,EAAA0V,MAAA92B,cAAAC,aAAAa,YAAAd,cAAAG,YACAvP,KAAA2P,OAAAC,EACA5P,KAAA8P,OAAA4yB,KAAAr4B,KAAAiF,YAAA,IAAAlF,aAAAkB,IACAtL,KAAAgQ,UAAAoc,MAAA/hB,KAAAiF,YAAA,IAAAlF,aAAA2F,IACA/P,KAAAyP,KAAA2c,MAAA/hB,KAAAiF,YAAA,IAAAlF,aAAA6F,IAGA,OAAAjQ,KAAA2P,OAOAhQ,cAAAqN,GAEA,OAAA,IAAAhN,KAAA8lC,QAAAxE,UAAAt0B,EAAA,IAAAwC,MAAA42B,qBACAlmC,IAAA4D,EAAA0L,MAAA,oDACA,SAIAxP,KAAA8lC,QAAAO,oBAMArmC,KAAA4tB,eAAApG,OAAA8e,UAAAtmC,KAAAmvB,SACAjvB,IAAA4D,EAAA0L,MAAA,4CACA,KAIAxP,KAAAumC,sBAKAvmC,KAAAwmC,WAAAxmC,KAAAymC,gBAhBAvmC,IAAA4D,EAAA0L,MAAA,4CACA,GA2BA7P,mBAEA,GAAA,IAAAK,KAAAmvB,QAAAnvB,KAAA8lC,QAAA/1B,cAAAiL,OAAA,IAAA3Q,KAAA,OACA,OAAA,EAIA,MAAA0F,EAAA/P,KAAA+lC,WAAAr3B,OACA,QAAA1O,KAAA8lC,QAAA/1B,cAAAiL,OAAAjL,KACA7P,IAAA4D,EAAA0L,MAAA,4CACA,GAWA7P,cAEA,IAAAK,KAAAgmC,MAAAzG,SACA,OAAA,EAIA,MAAAtvB,EAAAjQ,KAAAgmC,MAAAt3B,OACA,QAAA1O,KAAA8lC,QAAA71B,SAAA+K,OAAA/K,KACA/P,IAAA4D,EAAA0L,MAAA,uCACA,GAWA7P,6BAAA+mC,GAEA,IAAA1mC,KAAA8lC,QAAAa,uBAAAD,EAAA52B,QACA,OAAA,EAIA,MAAAE,QAAA02B,EAAAE,iBAAA5mC,KAAAkvB,OAAAlvB,KAAAuhC,SACA,QAAAvhC,KAAA+lC,WAAA/qB,OAAAhL,GAYArQ,6BAAA+mC,GAEA,GAAA1mC,KAAA8lC,QAAA3W,QAAAuX,EAAA52B,OAAAqf,OAEA,OADAjvB,IAAAsD,EAAAgM,MAAA,oCACA,EAIA,GAAAxP,KAAA8lC,QAAAxE,UAAAoF,EAAA52B,OAAAwxB,UAEA,OADAphC,IAAAsD,EAAAgM,MAAA,uCACA,EAIA,MAAA4xB,EAAAsF,EAAAh4B,OACA,IAAAU,cAAAC,aAAA2L,OAAAomB,GAAA,CACA,MAAAyF,QAAAH,EAAAp7B,MACAw7B,EAAAnF,WAAAkD,gBAAA7kC,KAAAkvB,QACA,IAAA6X,GAAA,EAEAC,EAAA,EACA,KAAAA,EAAAhnC,KAAA+lC,WAAApjC,OAAAqkC,IACA,GAAA5F,EAAApmB,OAAAhb,KAAA+lC,WAAAn3B,OAAAo4B,IAAA,CACAD,GAAA,EACA,MAAA7X,EAAA,IAAA7e,UAAA,GAAA/E,IAAAw7B,EAAAE,GACA,IAAArF,WAAAa,cAAAqE,EAAA3X,GAEA,OADAhvB,IAAAsD,EAAAgM,MAAA,2DACA,EAKA,IAAAu3B,EAEA,OADA7mC,IAAAsD,EAAAgM,MAAA,8CACA,EAOA,GAAAxP,KAAA8lC,QAAA1E,SAAApmB,OAAAomB,GAAA,CACA,GAAAphC,KAAA8lC,QAAA3W,SAAAuX,EAAA52B,OAAAqf,OAAA,EAEA,OADAjvB,IAAAsD,EAAAgM,MAAA,8CACA,EAGA,MACAO,SADA22B,EAAAE,iBAAA5mC,KAAAkvB,OAAAlvB,KAAAuhC,UACA7yB,OACA,IAAA1O,KAAA8lC,QAAA/1B,cAAAiL,OAAAjL,GAEA,OADA7P,IAAAsD,EAAAgM,MAAA,iDACA,MAKA,CAAA,GAAAxP,KAAA8lC,QAAA3W,SAAAuX,EAAA52B,OAAAqf,OAAA,EAEA,OADAjvB,IAAAsD,EAAAgM,MAAA,kDACA,EAGA,CAKA,MAAAZ,EAAA,IAAAq4B,QAGA,GAFAr4B,EAAAs4B,OAAAlnC,KAAA+lC,WAAAn3B,QACAA,EAAAu4B,UAAAT,EAAA12B,UAAApB,QACAA,EAAAjM,OAAA3C,KAAA8lC,QAAA3W,OAAAuX,EAAA52B,OAAAqf,OAEA,OADAjvB,IAAAsD,EAAAgM,MAAA,iDACA,EAIA,MAEA43B,EAFAzF,WAAAuD,eAAAllC,KAAAkvB,QACAyS,WAAAuD,eAAAwB,EAAAxX,QAEA,GAAAlvB,KAAA+lC,WAAApjC,OAAA+jC,EAAA12B,UAAArN,OAAAykC,EAEA,OADAlnC,IAAAsD,EAAAgM,MAAA,iDACA,EAIA,IAAA63B,GAAA,EACA,MAAAC,EAAAtnC,KAAA+lC,WAAAn3B,OACA24B,EAAAb,EAAA12B,UAAApB,OACA,IAAA,IAAAlM,EAAA,EAAAA,EAAA6kC,EAAA5kC,QAAAD,EAAA0kC,EAAAE,EAAA3kC,OAAAD,IACA,GAAA6kC,EAAA7kC,GAAAsY,OAAAssB,EAAA5kC,EAAA0kC,IACAC,GAAA,OACA,GAAAA,EAEA,OADAnnC,IAAAsD,EAAAgM,MAAA,mDACA,GAMA,OAAA,EAOA7P,oBAAA+mC,GAEA,aAAA1mC,KAAA2mC,uBAAAD,UAAA1mC,KAAAwnC,uBAAAd,GAQA/mC,uBAAAkmC,EAAA4B,EAAAtG,YAAAK,iBAEA,MAAA5yB,EAAA,GACAF,EAAA1O,KAAA0O,OAGAg5B,EAAA/F,WAAAgG,mBAAA3nC,KAAAsL,OACAs8B,EAAAjG,WAAAuD,eAAAW,GACAgC,EAAAx8B,KAAA4G,IAAAy1B,EAAAE,EAAA,EAAA,GAGA,IAAA,IAAAllC,EAAA,EAAAA,EAAAmlC,EAAAnlC,IACAkM,EAAAvF,KAAAqF,GASA,IAAA,IAAAhM,EAHAmlC,GADAD,EADAjG,WAAAuD,eAAAllC,KAAAkvB,SAKAxsB,EAAA1C,KAAAgQ,UAAArN,OAAAD,IACAkM,EAAAvF,KAAArJ,KAAAgQ,UAAApB,OAAAlM,IAGA,OAAA,IAAAugC,eAAAr0B,EAAAF,GAMA/O,cACA,OAAA,IAAA6P,MAAAxP,KAAA8lC,QAAA9lC,KAAA+lC,WAAA/lC,KAAAgmC,OAOArmC,OAAAuiB,GACA,OAAAA,aAAA1S,OACAxP,KAAA8lC,QAAA9qB,OAAAkH,EAAA4jB,UACA9lC,KAAA+lC,WAAA/qB,OAAAkH,EAAA6jB,cACA/lC,KAAAgmC,MAAAhmC,KAAAgmC,MAAAhrB,OAAAkH,EAAA8jB,QAAA9jB,EAAA8jB,OAMArmC,UACA,OAAAK,KAAAgmC,MAMArmC,SACA,QAAAK,KAAAgmC,MAMArmC,UACA,OAAAK,KAAAimC,UAAAjmC,KAAA,IAAAwP,MAAAxP,KAAA8lC,QAAA9lC,KAAA+lC,YAOApmC,OAAA8P,GACA,OAAAzP,KAAAwmC,SAAAxmC,KAAA,IAAAwP,MAAAxP,KAAA8lC,QAAA9lC,KAAA+lC,WAAAt2B,GAMAK,aACA,OAAA9P,KAAA8lC,QAMA91B,gBACA,OAAAhQ,KAAA+lC,WAMAt2B,WACA,GAAAzP,KAAAimC,UACA,MAAA,IAAA16B,MAAA,qCAEA,OAAAvL,KAAAgmC,MAMAzE,cACA,OAAAvhC,KAAA8lC,QAAAvE,QAMAH,eACA,OAAAphC,KAAA8lC,QAAA1E,SAMArxB,oBACA,OAAA/P,KAAA8lC,QAAA/1B,cAMAE,eACA,OAAAjQ,KAAA8lC,QAAA71B,SAMAoxB,mBACA,OAAArhC,KAAA8lC,QAAAzE,aAMAzY,YACA,OAAA5oB,KAAA8lC,QAAAld,MAMAsG,aACA,OAAAlvB,KAAA8lC,QAAA5W,OAMA2T,iBACA,OAAA7iC,KAAA8lC,QAAAjD,WAMA1T,aACA,OAAAnvB,KAAA8lC,QAAA3W,OAMAmS,gBACA,OAAAthC,KAAA8lC,QAAAxE,UAMAza,YACA,OAAA7mB,KAAA8lC,QAAAjf,MAMA8c,gBACA,OAAA3jC,KAAAgmC,MAAAhmC,KAAAgmC,MAAArC,eAAAtgC,EAMAqM,mBACA,OAAA1P,KAAAgmC,MAAAhmC,KAAAgmC,MAAAt2B,kBAAArM,EAMAqgC,gBACA,OAAA1jC,KAAAgmC,MAAAhmC,KAAAgmC,MAAAtC,eAAArgC,EAMAugC,qBACA,OAAA5jC,KAAAgmC,MAAAhmC,KAAAgmC,MAAApC,oBAAAvgC,EAMAshC,uBACA,OAAA3kC,KAAAgmC,MAAAhmC,KAAAgmC,MAAArB,sBAAAthC,EAOA1D,KAAAif,GACA,OAAA5e,KAAA8lC,QAAAp3B,KAAAkQ,GAOAjf,IAAAif,GACA,OAAA5e,KAAA8lC,QAAAx6B,IAAAsT,GAMAjf,eAAAmN,GACA,GAAAA,aAAA0C,MAAA,OAAA1C,EACA,GAAA,iBAAAA,EAAA,OAAA0C,MAAA6rB,UAAAvuB,GACA,GAAA,iBAAAA,EAAA,OAAA0C,MAAAF,YAAA3E,YAAAyX,QAAAtV,IACA,MAAA,IAAAvB,MAAA,iBAMA5L,iBAAA27B,GACA,MAAAxrB,EAAA,IAAAqxB,YACA92B,KAAAkoB,QAAA+I,EAAA8F,UACA/2B,KAAAkoB,QAAA+I,EAAAvrB,eACA1F,KAAAkoB,QAAA+I,EAAArrB,UACA5F,KAAAkoB,QAAA+I,EAAA+F,cACA/F,EAAA1S,MACA0S,EAAAnM,OACAmM,EAAAgG,UACAhG,EAAAzU,MACAyU,EAAAiG,SAEAvxB,EAAA,IAAAizB,gBAAA3H,EAAAtrB,UAAApB,QAAA0sB,EAAAtrB,WAAA0Q,IAAAonB,GAAAz9B,KAAAkoB,QAAAuV,IAAAz9B,KAAAkoB,QAAA+I,EAAA8F,WACA,IAAA3xB,EAAA,KASA,OARA6rB,EAAAqI,gBAAAtgC,IAAAi4B,EAAAoI,WAAAzgC,MAAAiP,QAAAopB,EAAA5rB,eAAAzM,MAAAiP,QAAAopB,EAAAsI,kBACAn0B,EAAA,IAAAg0B,UACA5P,QAAAtB,QAAA+I,EAAAqI,WACArI,EAAA5rB,aAAAgR,IAAA0jB,GAAA/G,YAAA9K,QAAA6R,IACAz5B,YAAA4nB,QAAA+I,EAAAoI,WACApI,EAAAsI,eAAAljB,IAAAqnB,GAAArL,cAAAnK,QAAAwV,MAGA,IAAAv4B,MAAAM,EAAAE,EAAAP,GAGA9P,WACA,sBAAAK,KAAAmvB,eAAAnvB,KAAAohC,YAGAzhC,UACA,MAAA27B,EAAA,CACAiG,QAAAvhC,KAAAuhC,QACA7yB,KAAA1O,KAAA0O,OAAAquB,UACAqE,SAAAphC,KAAAohC,SAAArE,UACAhtB,cAAA/P,KAAA+P,cAAAgtB,UACA9sB,SAAAjQ,KAAAiQ,SAAA8sB,UACAsE,aAAArhC,KAAAqhC,aAAAtE,UACAnU,MAAA5oB,KAAA4oB,MACAia,WAAA7iC,KAAA6iC,WAAAjgC,WACAusB,OAAAnvB,KAAAmvB,OACAmS,UAAAthC,KAAAshC,UACAza,MAAA7mB,KAAA6mB,MACA7W,UAAAhQ,KAAAgQ,UAAApB,OAAA8R,IAAAonB,GAAAA,EAAA/K,YAQA,OANA/8B,KAAAwmC,WACAlL,EAAAqI,UAAA3jC,KAAA2jC,UAAA5G,UACAzB,EAAA5rB,aAAA1P,KAAA0P,aAAAgR,IAAA0jB,GAAAA,EAAArH,WACAzB,EAAAoI,UAAA/4B,YAAA4mB,MAAAvxB,KAAA0jC,WACApI,EAAAsI,eAAA5jC,KAAA4jC,eAAAljB,IAAAqnB,GAAAA,EAAAhL,YAEAzB,GAIA9rB,MAAA42B,oBAAA,IACA9mC,MAAAQ,SAAA0P,OCplBA,MAAA6tB,YAcA19B,YAAAoV,EAAAspB,EAAA2J,EAAA9J,EAAAX,EAAAzZ,EAAA6X,EAAAsM,EAAA7iC,EAAAi3B,EAAAnvB,EAAAkC,cAAAG,YACA,MAAA24B,EAAA,IAAA73B,UAAAyT,GACA,KAAAua,aAAAxK,SAAA,MAAA,IAAAtoB,MAAA,oBACA,IAAA4S,YAAA8H,QAAA+hB,GAAA,MAAA,IAAAz8B,MAAA,yBACA,KAAA2yB,aAAArK,SAAA,MAAA,IAAAtoB,MAAA,uBACA,IAAA4S,YAAA8H,QAAAsX,GAAA,MAAA,IAAAhyB,MAAA,4BACA,IAAA4S,YAAA4G,UAAAmjB,IAAAA,EAAAntB,GAAA,GAAA,MAAA,IAAAxP,MAAA,mBACA,IAAA4S,YAAAwgB,SAAAhD,GAAA,MAAA,IAAApwB,MAAA,iCACA,IAAA4S,YAAA8H,QAAAgiB,KAAAA,GAAA5K,YAAAC,KAAA,KAAA,EAAA,MAAA,IAAA/xB,MAAA,mBACA,KAAAnG,aAAAuI,YAAAwQ,YAAAsjB,SAAAr8B,EAAAgH,aAAA,MAAA,IAAAb,MAAA,kBACA,GAAA8wB,MAAAA,aAAA1uB,cAAAwQ,YAAAsjB,SAAApF,EAAAjwB,aAAA,MAAA,IAAAb,MAAA,mBACA,IAAA4S,YAAA8H,QAAA/Y,GAAA,MAAA,IAAA3B,MAAA,uBAGAvL,KAAAmoC,QAAApzB,EAEA/U,KAAA4+B,QAAAP,EAEAr+B,KAAAooC,YAAAJ,EAEAhoC,KAAA6+B,WAAAX,EAEAl+B,KAAAqoC,eAAA9K,EAEAv9B,KAAAsoC,OAAAJ,EAEAloC,KAAAuoC,KAAA/gB,OAAAghB,MAAA7M,GAEA37B,KAAAyoC,WAAAv7B,EAEAlN,KAAA0oC,qBAAA/M,EAEA37B,KAAA2oC,OAAAV,EAEAjoC,KAAA4oC,MAAAxjC,EAEApF,KAAA6oC,OAAAxM,EAEAr8B,KAAA6+B,aAAAhL,QAAAmF,oBAAAh5B,KAAA6+B,WAAA7+B,KAAAm+B,8BAOAx+B,mBAAAif,GACA,MAAA7J,EAAA6J,EAAAoG,YAGA,GAFApG,EAAAiF,WAEAwZ,YAAAyL,WAAA3N,IAAApmB,GAAA,MAAA,IAAAxJ,MAAA,4BACA,OAAA8xB,YAAAyL,WAAAtmC,IAAAuS,GAAAzF,YAAAsP,GAOAjf,iBAAAif,GAaA,OAZAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA+oC,wBACA1jB,YAAArlB,KAAA4oC,MAAAx8B,YACAwS,EAAAhT,MAAA5L,KAAA4oC,OACA5oC,KAAA4+B,QAAA1uB,UAAA0O,GACAA,EAAAwG,WAAAplB,KAAAooC,aACApoC,KAAA6+B,WAAA3uB,UAAA0O,GACAA,EAAAwG,WAAAplB,KAAAqoC,gBACAzpB,EAAAwc,aAAAp7B,KAAAsoC,QACA1pB,EAAAwc,aAAAp7B,KAAAuoC,MACA3pB,EAAA/S,YAAA7L,KAAA0oC,sBACA9pB,EAAAwG,WAAAplB,KAAAyoC,YACA7pB,EAAAwG,WAAAplB,KAAA2oC,QACA/pB,EAIAmqB,4BACA,OAAA,EACA/oC,KAAA4oC,MAAAx8B,WACApM,KAAA4+B,QAAAhR,eACA,EACA5tB,KAAA6+B,WAAAjR,eACA,EACA,GACA,GACA,EACA,EACA,EAOAjuB,OAAAuN,GAIA,YAHA7J,IAAArD,KAAA2P,SACA3P,KAAA2P,OAAA3P,KAAA6P,QAAA3C,IAEAlN,KAAA2P,OAQAhQ,QAAAuN,EAAAkC,cAAAG,YACA,OAAAvP,KAAAyoC,aAAAv7B,GACAhN,IAAA4D,EAAAu5B,YAAA,2CAAAr9B,OACA,GAGAA,KAAA6+B,WAAA7jB,OAAAhb,KAAA4+B,UACA1+B,IAAA4D,EAAAu5B,YAAA,sCAAAr9B,OACA,GAEA66B,QAAAK,SAAAC,IAAAn7B,KAAAooC,cAAAvN,QAAAK,SAAAC,IAAAn7B,KAAAqoC,gBAIAxN,QAAAK,SAAA14B,IAAAxC,KAAAooC,aAAAY,0BAAAhpC,MAIA66B,QAAAK,SAAA14B,IAAAxC,KAAAqoC,gBAAA1I,0BAAA3/B,QAIAA,KAAAuoC,KAAAxtB,GAAAyM,OAAAghB,MAAAxoC,KAAA0oC,yBACAxoC,IAAA4D,EAAAu5B,YAAA,qBAAAr9B,OACA,IALAE,IAAA4D,EAAAu5B,YAAA,wBAAAr9B,OACA,IALAE,IAAA4D,EAAAu5B,YAAA,qBAAAr9B,OACA,IALAE,IAAA4D,EAAAu5B,YAAA,uBAAAr9B,OACA,GAkBA4tB,qBACA,MAAA,IAAAriB,MAAA,gDAOA5L,UAAAif,GACA,MAAA,IAAArT,MAAA,gDAMA5L,OAGA,OADAK,KAAAosB,MAAApsB,KAAAosB,OAAA/hB,KAAAiiB,MAAAtsB,KAAAw/B,oBACAx/B,KAAAosB,MAOAzsB,QAAAuiB,GACA,OAAAliB,KAAA87B,IAAAlpB,IAAA5S,KAAA4tB,gBAAA1W,GAAAgL,EAAA4Z,IAAAlpB,IAAAsP,EAAA0L,kBAAA,EACA5tB,KAAA87B,IAAAlpB,IAAA5S,KAAA4tB,gBAAA5W,GAAAkL,EAAA4Z,IAAAlpB,IAAAsP,EAAA0L,iBAAA,EACA5tB,KAAA4tB,eAAA1L,EAAA0L,gBAAA,EACA5tB,KAAA4tB,eAAA1L,EAAA0L,eAAA,EACA5tB,KAAA87B,IAAA5kB,GAAAgL,EAAA4Z,MAAA,EACA97B,KAAA87B,IAAA9kB,GAAAkL,EAAA4Z,KAAA,EACA97B,KAAA8jB,MAAA5M,GAAAgL,EAAA4B,QAAA,EACA9jB,KAAA8jB,MAAA9M,GAAAkL,EAAA4B,OAAA,EACA9jB,KAAAskC,kBAAApiB,GAOAviB,kBAAAuiB,GAEA,MAAA+mB,EAAAjpC,KAAA6+B,WAAAptB,QAAAyQ,EAAA2c,YACA,GAAA,IAAAoK,EAAA,OAAAA,EACA,GAAAjpC,KAAA0oC,qBAAAxmB,EAAAwmB,qBAAA,OAAA,EACA,GAAA1oC,KAAA0oC,qBAAAxmB,EAAAwmB,qBAAA,OAAA,EACA,GAAA1oC,KAAAuoC,KAAArxB,GAAAgL,EAAAqmB,MAAA,OAAA,EACA,GAAAvoC,KAAAuoC,KAAAvxB,GAAAkL,EAAAqmB,MAAA,OAAA,EACA,GAAAvoC,KAAAsoC,OAAApxB,GAAAgL,EAAAomB,QAAA,OAAA,EACA,GAAAtoC,KAAAsoC,OAAAtxB,GAAAkL,EAAAomB,QAAA,OAAA,EACA,MAAAY,EAAAlpC,KAAA4+B,QAAAntB,QAAAyQ,EAAA0c,SACA,OAAA,IAAAsK,EAAAA,EACAlpC,KAAAqoC,eAAAnmB,EAAAmmB,gBAAA,EACAroC,KAAAqoC,eAAAnmB,EAAAmmB,eAAA,EACAroC,KAAAooC,YAAAlmB,EAAAkmB,aAAA,EACApoC,KAAAooC,YAAAlmB,EAAAkmB,YAAA,EACApoC,KAAA2oC,OAAAzmB,EAAAymB,QAAA,EACA3oC,KAAA2oC,OAAAzmB,EAAAymB,OAAA,EACAh+B,YAAA8G,QAAAzR,KAAA4oC,MAAA1mB,EAAA0mB,OAOAjpC,OAAAuiB,GAGA,OAAAA,aAAAmb,aACAr9B,KAAA4+B,QAAA5jB,OAAAkH,EAAA0c,UACA5+B,KAAAooC,cAAAlmB,EAAAkmB,aACApoC,KAAA6+B,WAAA7jB,OAAAkH,EAAA2c,aACA7+B,KAAAqoC,iBAAAnmB,EAAAmmB,gBACAroC,KAAAsoC,OAAAvtB,GAAAmH,EAAAomB,SACAtoC,KAAAuoC,KAAAxtB,GAAAmH,EAAAqmB,OACAvoC,KAAA0oC,uBAAAxmB,EAAAwmB,sBACA1oC,KAAAyoC,aAAAvmB,EAAAumB,YACAzoC,KAAA2oC,SAAAzmB,EAAAymB,QACAh+B,YAAAqQ,OAAAhb,KAAA4oC,MAAA1mB,EAAA0mB,OAMAjpC,WACA,MAAA,yBACAK,KAAA4+B,QAAArN,yBACAvxB,KAAA6+B,WAAAtN,qBACAvxB,KAAAsoC,OAAA1lC,sBACA5C,KAAAuoC,KAAA3lC,sCACA5C,KAAA0oC,sCACA1oC,KAAAyoC,aACA,IAGA9oC,UACA,MAAAyF,EAAAy1B,QAAAK,SAAA14B,IAAAxC,KAAAu9B,eAAAG,YAAA19B,KAAAoF,MACAA,EAAA+uB,IAAAxpB,YAAA4mB,MAAAvxB,KAAAoF,MACA,MAAAi3B,EAAAxB,QAAAK,SAAA14B,IAAAxC,KAAAgoC,YAAAhK,aAAAh+B,KAAAq8B,OAEA,OADAA,EAAAlI,IAAAxpB,YAAA4mB,MAAAvxB,KAAAq8B,OACA,CACA8M,gBAAAnpC,KAAA0O,OAAAquB,UACAhoB,OAAAsoB,YAAA+L,OAAAxmC,SAAA5C,KAAAmoC,SACA9J,OAAAr+B,KAAAq+B,OAAAtB,UACAiL,WAAAnN,QAAAU,KAAA34B,SAAA5C,KAAAgoC,YACA9J,UAAAl+B,KAAAk+B,UAAAnB,UACAQ,cAAA1C,QAAAU,KAAA34B,SAAA5C,KAAAu9B,eACAzZ,MAAA9jB,KAAA8jB,MAAAlhB,WACAk5B,IAAA97B,KAAA87B,IAAAl5B,WACAymC,WAAArpC,KAAAqpC,WAAAzmC,WACA+4B,oBAAA37B,KAAA27B,oBACA2N,QAAAl6B,cAAAm6B,uBAAAvpC,KAAAkN,WACA+6B,MAAAjoC,KAAAioC,MACA7iC,KAAAA,EACAi3B,MAAAA,EACAr3B,KAAAhF,KAAA4tB,eACAhe,MAAA5P,KAAAu/B,UAQA5/B,iBAAA27B,GACA,IAAAA,EAAA,MAAA,IAAA/vB,MAAA,8BACA,MAAAwJ,EAAAsoB,YAAA+L,OAAA7W,QAAA+I,EAAAvmB,QACA,IAAAsoB,YAAAyL,WAAA3N,IAAApmB,GAAA,MAAA,IAAAxJ,MAAA,4BACA,OAAA8xB,YAAAyL,WAAAtmC,IAAAuS,GAAAsmB,UAAAC,GAOA37B,eAAAykC,GACA,GAAAA,aAAA/G,YAAA,OAAA+G,EACA,GAAA,iBAAAA,EAAA,OAAA/G,YAAAhC,UAAA+I,GACA,GAAA,iBAAAA,EAAA,OAAA/G,YAAA/tB,YAAA,IAAAlF,aAAAO,YAAAyX,QAAAgiB,KACA,MAAA,IAAA74B,MAAA,8BAMA5L,6BACA,MAAAykC,EAAA/G,YAAA/tB,YAAAtP,KAAAkQ,aAGA,OAFAk0B,EAAAvF,WAAAhL,QAAAT,KACAgR,EAAAhY,MAAA,KACAyH,QAAAC,SAAAsQ,EAAA11B,QAIAqG,aACA,OAAA/U,KAAAmoC,QAIA9J,aACA,OAAAr+B,KAAA4+B,QAIAoJ,iBACA,OAAAhoC,KAAAooC,YAIAlK,gBACA,OAAAl+B,KAAA6+B,WAIAtB,oBACA,OAAAv9B,KAAAqoC,eAIAvkB,YACA,OAAA9jB,KAAAsoC,OAIAxM,UACA,OAAA97B,KAAAuoC,KAIAc,iBACA,OAAArpC,KAAAuoC,KAAA31B,IAAA5S,KAAA4tB,gBAIA1gB,gBACA,OAAAlN,KAAAyoC,WAIA9M,0BACA,OAAA37B,KAAA0oC,qBAIAT,YACA,OAAAjoC,KAAA2oC,OAOAhpC,QAAA6pC,GACA,OAAAxpC,KAAA2oC,OAAAa,GAAA,EAIApkC,WACA,OAAApF,KAAA4oC,MAIAvM,YACA,OAAAr8B,KAAA6oC,OAKAxM,UAAAA,GACAr8B,KAAA6oC,OAAAxM,GAQAgB,YAAA+L,OAAA,CACA9M,MAAA,EACAmN,SAAA,GAKApM,YAAA+L,OAAAxmC,SAAA,SAAAmS,GACA,OAAAA,GACA,KAAAsoB,YAAA+L,OAAA9M,MAAA,MAAA,QACA,KAAAe,YAAA+L,OAAAK,SAAA,MAAA,WAEA,MAAA,IAAAl+B,MAAA,+BAMA8xB,YAAA+L,OAAA7W,QAAA,SAAAxd,GACA,GAAA,iBAAAA,EAAA,OAAAA,EACA,OAAAA,GACA,IAAA,QAAA,OAAAsoB,YAAA+L,OAAA9M,MACA,IAAA,WAAA,OAAAe,YAAA+L,OAAAK,SAEA,MAAA,IAAAl+B,MAAA,+BAKA8xB,YAAAC,KAAA,CACAoM,KAAA,EACA1Q,kBAAA,EACA2Q,IAAA,GAGAtM,YAAAyL,WAAA,IAAArhC,IAEAnI,MAAAQ,SAAAu9B,aCzaA,MAAAH,eAKAv9B,yBAAA67B,GACA,IACA,MAAAhtB,EAAA,IAAApE,aAAAoxB,EAAAa,OACAA,EAAAa,eAAA5tB,YAAAd,GAGA,OAAAA,EAAAqV,UAAArV,EAAApC,YACAlM,IAAA4D,EAAAo5B,eAAA,sCACA,GAGAb,EAAAkD,OAAA/D,EAAA6C,OAAA7C,EAAAgE,oBACA,MAAA9+B,GAEA,OADAR,IAAA4D,EAAAo5B,gDAAAx8B,EAAAqC,SAAArC,MACA,GASAf,iBAAA00B,EAAA6D,GACA,OAAA,IAAAgF,eAAA7I,EAAA,IAAAzH,WAAA,IAAAsL,GASAv4B,gBAAAiqC,EAAAnW,EAAAyE,GACA,MAAA6F,EAAAnR,WAAA0S,QAAA7L,EAAAmW,GACA,OAAA,IAAA1M,eAAA0M,EAAA7L,EAAA7F,GAQAv4B,YAAA00B,EAAA0J,EAAA7F,GACA,KAAA7D,aAAAhB,WAAA,MAAA,IAAA9nB,MAAA,wBACA,KAAAwyB,aAAAnR,YAAA,MAAA,IAAArhB,MAAA,wBACA,GAAA2sB,KAAAA,aAAA7B,WAAA,MAAA,IAAA9qB,MAAA,uBAMAvL,KAAA6pC,WAAAxV,EAKAr0B,KAAA8pC,YAAA/L,EAKA/9B,KAAA+pC,WAAA7R,EAOAv4B,mBAAAif,GACA,MAAAyV,EAAAhB,UAAA/jB,YAAAsP,GACAmf,EAAAnR,WAAAtd,YAAAsP,GACAsZ,EAAA7B,UAAA/mB,YAAAsP,GACA,OAAA,IAAAse,eAAA7I,EAAA0J,EAAA7F,GAOAv4B,UAAAif,GAYA,OAXAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,gBACA5tB,KAAA6pC,WAAA35B,UAAA0O,GACA5e,KAAA8pC,YAAA55B,UAAA0O,GAKA5e,KAAA+pC,YACA/pC,KAAA+pC,WAAA75B,UAAA0O,GAGAA,EAIAgP,qBACA,OAAA5tB,KAAA6pC,WAAAjc,eACA5tB,KAAA8pC,YAAAlc,gBACA5tB,KAAA+pC,WAAA/pC,KAAA+pC,WAAAnc,eAAA,GAGAoc,6BACA,OAAA3W,UAAAnoB,KAAA,IAAA0hB,WAAA,IAAAgB,eAAAyI,UAAAnrB,KAOAvL,OAAAuiB,GACA,OAAAA,aAAAgb,gBACAl9B,KAAA6pC,WAAA7uB,OAAAkH,EAAA2nB,aACA7pC,KAAA8pC,YAAA9uB,OAAAkH,EAAA4nB,eACA9pC,KAAA+pC,WAAA/pC,KAAA+pC,WAAA/uB,OAAAkH,EAAA6nB,YAAA/pC,KAAA+pC,aAAA7nB,EAAA6nB,YAQApqC,OAAA0+B,EAAAj5B,GACA,OAAA,OAAAi5B,GAAAr+B,KAAA6/B,WAAAxB,GAKAr+B,KAAA+pC,aAKA/pC,KAAA+pC,WAAAxK,OAAAv/B,KAAA6pC,WAAAzkC,KACAlF,IAAA4D,EAAAo5B,eAAA,kDACA,IANAh9B,IAAA4D,EAAAo5B,eAAA,kDACA,IANAh9B,IAAA4D,EAAAo5B,eAAA,kEACA,GAoBAv9B,WAAA0+B,GACA,MAAA4L,EAAAjqC,KAAA8pC,YAAAtG,YAAAxjC,KAAA6pC,YAEA,OADAhW,QAAAC,SAAAmW,GACAjvB,OAAAqjB,GAIAhK,gBACA,OAAAr0B,KAAA6pC,WAIA9L,iBACA,OAAA/9B,KAAA8pC,YAIA5R,gBACA,OAAAl4B,KAAA+pC,WAIA7R,cAAAA,GACAl4B,KAAA+pC,WAAA7R,GAIA54B,MAAAQ,SAAAo9B,gBCjLA,MAAAgN,yBAAA7M,YASA19B,YAAAwqC,EAAAjM,EAAApa,EAAA6X,EAAAzD,EAAAhrB,GACA,KAAAi9B,aAAA9W,WAAA,MAAA,IAAA9nB,MAAA,0BAEA,QAAAlI,IAAA60B,KAAAA,aAAA7B,WAAA,MAAA,IAAA9qB,MAAA,uBAEA,MAAA8wB,EAAAa,eAAAkN,UAAAD,EAAAjS,GACA/wB,MAAAk2B,YAAA+L,OAAA9M,MAAA6N,EAAAtM,YAAAhD,QAAAU,KAAAe,MAAA4B,EAAArD,QAAAU,KAAAe,MAAAxY,EAAA6X,EAAA0B,YAAAC,KAAAoM,KAAA,IAAA/7B,WAAA,GAAA0uB,EAAAnsB,YAAAhD,GAMAlN,KAAAqqC,gBAAAhO,EAOA18B,mBAAAif,GACA,MAAAjY,EAAAiY,EAAAoG,YACA+G,OAAA0Z,KAAA9+B,IAAA02B,YAAA+L,OAAA9M,OAEA,MAAA6N,EAAA9W,UAAA/jB,YAAAsP,GACAsf,EAAArK,QAAAvkB,YAAAsP,GACAkF,EAAAlF,EAAAqe,cAEAtB,GADA/c,EAAAqe,cACAre,EAAAsG,cACAhY,EAAA0R,EAAAoG,YACAkT,EAAA7B,UAAA/mB,YAAAsP,GACA,OAAA,IAAAsrB,iBAAAC,EAAAjM,EAAApa,EAAA6X,EAAAzD,EAAAhrB,GAOAvN,iBAAA27B,GACA,IAAAA,EAAA,MAAA,IAAA/vB,MAAA,8BACA,OAAA,IAAA2+B,iBACA7W,UAAAd,QAAA+I,EAAAe,MAAAhI,WAAAiH,EAAA6O,cACAtW,QAAAtB,QAAA+I,EAAA4C,WACA5C,EAAAxX,MACAwX,EAAAK,oBACAtF,UAAA9D,QAAA+I,EAAAe,MAAAnE,WAAAoD,EAAApD,WACA9oB,cAAAk7B,iBAAAhP,EAAAgO,SAAAhO,EAAApuB,YAQAvN,UAAAif,GAUA,OATAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAxI,WAAAiY,YAAA+L,OAAA9M,OACAt8B,KAAAmqC,aAAAj6B,UAAA0O,GACA5e,KAAA6+B,WAAA3uB,UAAA0O,GACAA,EAAAwc,aAAAp7B,KAAAsoC,QACA1pB,EAAAwc,aAAAp7B,KAAAuoC,MACA3pB,EAAA/S,YAAA7L,KAAA0oC,sBACA9pB,EAAAwG,WAAAplB,KAAAyoC,YACAzoC,KAAAk4B,UAAAhoB,UAAA0O,GACAA,EAIAgP,qBACA,OAAA,EACA5tB,KAAAmqC,aAAAvc,eACA5tB,KAAA6+B,WAAAjR,eACA,GACA,GACA,EACA,EACA5tB,KAAAk4B,UAAAtK,eAMAuc,mBACA,OAAAnqC,KAAAqqC,gBAAAhW,UAMA6D,gBACA,OAAAl4B,KAAAqqC,gBAAAnS,UAMAA,cAAAA,GACAl4B,KAAAqqC,gBAAAnS,UAAAA,EACAl4B,KAAA6oC,OAAA7oC,KAAAqqC,gBAAAn6B,aAGAmtB,YAAAyL,WAAA7gC,IAAAo1B,YAAA+L,OAAA9M,MAAA4N,kBACA5qC,MAAAQ,SAAAoqC,kBC9GA,MAAAK,4BAAAlN,YAcA19B,YAAA0+B,EAAA2J,EAAA9J,EAAAX,EAAAzZ,EAAA6X,EAAAsM,EAAA7iC,EAAAi3B,EAAA,IAAA1uB,WAAA,GAAAT,GACA/F,MAAAk2B,YAAA+L,OAAAK,SAAApL,EAAA2J,EAAA9J,EAAAX,EAAAzZ,EAAA6X,EAAAsM,EAAA7iC,EAAAi3B,EAAAnvB,GAOAvN,mBAAAif,GACA,MAAAjY,EAAAiY,EAAAoG,YACA+G,OAAA0Z,KAAA9+B,IAAA02B,YAAA+L,OAAAK,UAEA,MAAAe,EAAA5rB,EAAAqG,aACA7f,EAAAwZ,EAAA8G,KAAA8kB,GACAnM,EAAAxK,QAAAvkB,YAAAsP,GACAopB,EAAAppB,EAAAoG,YACAkZ,EAAArK,QAAAvkB,YAAAsP,GACA2e,EAAA3e,EAAAoG,YACAlB,EAAAlF,EAAAqe,cAEAtB,GADA/c,EAAAqe,cACAre,EAAAsG,cACAhY,EAAA0R,EAAAoG,YACAijB,EAAArpB,EAAAoG,YACAylB,EAAA7rB,EAAAqG,aACAoX,EAAAzd,EAAA8G,KAAA+kB,GACA,OAAA,IAAAF,oBAAAlM,EAAA2J,EAAA9J,EAAAX,EAAAzZ,EAAA6X,EAAAsM,EAAA7iC,EAAAi3B,EAAAnvB,GAOAvN,iBAAA27B,GACA,IAAAA,EAAA,MAAA,IAAA/vB,MAAA,8BACA,OAAA,IAAAg/B,oBACA1W,QAAAtB,QAAA+I,EAAA+C,QACAxD,QAAAU,KAAAhJ,QAAA+I,EAAA0M,YACAnU,QAAAtB,QAAA+I,EAAA4C,WACArD,QAAAU,KAAAhJ,QAAA+I,EAAAiC,eACAjC,EAAAxX,MACAwX,EAAAK,oBACAL,EAAA2M,MACAt9B,YAAA4nB,aAAAlvB,IAAAi4B,EAAAl2B,KAAA+uB,IAAAmH,EAAAl2B,KAAAk2B,EAAAl2B,KAAA+uB,KACAxpB,YAAA4nB,aAAAlvB,IAAAi4B,EAAAe,MAAAlI,IAAAmH,EAAAe,MAAAf,EAAAe,MAAAlI,KACA/kB,cAAAk7B,iBAAAhP,EAAAgO,SAAAhO,EAAApuB,YAQAvN,UAAAif,GAMA,OALAA,EAAAA,GAAA,IAAAxU,aAAApK,KAAA4tB,iBACAxI,WAAAiY,YAAA+L,OAAAK,UACAzpC,KAAAw/B,iBAAA5gB,GACAA,EAAAyG,YAAArlB,KAAA6oC,OAAAz8B,YACAwS,EAAAhT,MAAA5L,KAAA6oC,QACAjqB,EAIAgP,qBACA,OAAA,EACA5tB,KAAA+oC,sBACA,EACA/oC,KAAA6oC,OAAAz8B,YAIAixB,YAAAyL,WAAA7gC,IAAAo1B,YAAA+L,OAAAK,SAAAc,qBACAjrC,MAAAQ,SAAAyqC","file":"worker.js","sourcesContent":["class Class {\r\n static get scope() {\r\n if (typeof exports !== 'undefined') return exports;\r\n if (typeof self !== 'undefined') return self;\r\n return window;\r\n }\r\n\r\n static register(cls) {\r\n if (typeof exports !== 'undefined') exports[cls.name] = cls;\r\n }\r\n}\r\nClass.register(Class);\r\n","class LogNative {\r\n constructor() {\r\n this._global_level = Log.INFO;\r\n this._tag_levels = {};\r\n try {\r\n if (window.localStorage) {\r\n try {\r\n let c = window.localStorage.getItem('log_tag_levels');\r\n if (c && typeof c === 'string') c = JSON.parse(c);\r\n if (c && typeof c === 'object') this._tag_levels = c;\r\n } catch (e) {\r\n console.warn('Failed to load log configuration from local storage.');\r\n }\r\n }\r\n } catch (e) {\r\n // ignore\r\n }\r\n }\r\n\r\n isLoggable(tag, level) {\r\n if (tag && this._tag_levels[tag]) {\r\n return this._tag_levels[tag] <= level;\r\n }\r\n if (this._tag_levels['*']) {\r\n return this._tag_levels['*'] <= level;\r\n }\r\n return this._global_level <= level;\r\n }\r\n\r\n setLoggable(tag, level) {\r\n if (tag && tag.name) tag = tag.name;\r\n this._tag_levels[tag] = level;\r\n if (window.localStorage) {\r\n window.localStorage.setItem('log_tag_levels', JSON.stringify(this._tag_levels));\r\n }\r\n }\r\n\r\n msg(level, tag, args) {\r\n if (tag && tag.name) tag = tag.name;\r\n if (!this.isLoggable(tag, level)) return;\r\n if (tag) args.unshift(tag + ':');\r\n args.unshift(`[${Log.Level.toStringTag(level)} ${new Date().toTimeString().substr(0, 8)}]`);\r\n if (console.error && level >= Log.ERROR) {\r\n console.error.apply(console, args);\r\n } else if (console.warn && level >= Log.WARNING) {\r\n console.warn.apply(console, args);\r\n } else if (console.info && level >= Log.INFO) {\r\n console.info.apply(console, args);\r\n } else if (console.debug && level >= Log.DEBUG) {\r\n console.debug.apply(console, args);\r\n } else if (console.trace && level <= Log.TRACE) {\r\n console.trace.apply(console, args);\r\n } else {\r\n console.log.apply(console, args);\r\n }\r\n }\r\n}\r\nClass.register(LogNative);\r\n","class Log {\r\n /**\r\n * @returns {Log}\r\n */\r\n static get instance() {\r\n if (!Log._instance) {\r\n Log._instance = new Log(new LogNative());\r\n }\r\n return Log._instance;\r\n }\r\n\r\n /**\r\n * @param {LogNative} native\r\n */\r\n constructor(native) {\r\n /** @type {LogNative} */\r\n this._native = native;\r\n }\r\n\r\n /**\r\n * @param {string} tag\r\n * @param {Log.Level} level\r\n */\r\n setLoggable(tag, level) {\r\n this._native.setLoggable(tag, Log.Level.get(level));\r\n }\r\n\r\n /** @type {Log.Level} */\r\n get level() {\r\n return this._native._global_level;\r\n }\r\n\r\n /** @type {Log.Level} */\r\n set level(l) {\r\n this._native._global_level = Log.Level.get(l);\r\n }\r\n\r\n /**\r\n * @param {Log.Level} level\r\n * @param {string|{name:string}} tag\r\n * @param {Array} args\r\n */\r\n msg(level, tag, args) {\r\n if (this._native.isLoggable(tag, level)) {\r\n for (let i = 0; i < args.length; ++i) {\r\n if (typeof args[i] === 'function') {\r\n args[i] = args[i]();\r\n }\r\n if (typeof args[i] === 'object') {\r\n if (typeof args[i].toString === 'function') {\r\n args[i] = args[i].toString();\r\n } else if (args[i].constructor && args[i].constructor.name) {\r\n args[i] = `{Object: ${args[i].constructor.name}}`;\r\n } else {\r\n args[i] = '{Object}';\r\n }\r\n }\r\n }\r\n this._native.msg(level, tag, args);\r\n }\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static d(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.DEBUG, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static e(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.ERROR, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static i(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.INFO, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static v(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.VERBOSE, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static w(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.WARNING, tag, args);\r\n }\r\n\r\n /**\r\n * @param {?string|{name:string}} [tag=undefined]\r\n * @param {string|function():string} message\r\n * @param {...*} args\r\n */\r\n static t(tag, message, ...args) {\r\n if (arguments.length >= 2) {\r\n tag = arguments[0];\r\n args = Array.prototype.slice.call(arguments, 1);\r\n } else {\r\n tag = undefined;\r\n args = Array.prototype.slice.call(arguments, 0);\r\n }\r\n Log.instance.msg(Log.TRACE, tag, args);\r\n }\r\n}\r\n\r\n/**\r\n * @enum {number|string}\r\n */\r\nLog.Level = {\r\n TRACE: 1,\r\n VERBOSE: 2,\r\n DEBUG: 3,\r\n INFO: 4,\r\n WARNING: 5,\r\n ERROR: 6,\r\n ASSERT: 7,\r\n\r\n /**\r\n * @param {Log.Level} level\r\n * @returns {string}\r\n */\r\n toStringTag: function (level) {\r\n switch (level) {\r\n case Log.Level.TRACE:\r\n return 'T';\r\n case Log.Level.VERBOSE:\r\n return 'V';\r\n case Log.Level.DEBUG:\r\n return 'D';\r\n case Log.Level.INFO:\r\n return 'I';\r\n case Log.Level.WARNING:\r\n return 'W';\r\n case Log.Level.ERROR:\r\n return 'E';\r\n case Log.Level.ASSERT:\r\n return 'A';\r\n default:\r\n return '*';\r\n }\r\n },\r\n\r\n toString: function (level) {\r\n switch (level) {\r\n case Log.Level.TRACE:\r\n return 'trace';\r\n case Log.Level.VERBOSE:\r\n return 'verbose';\r\n case Log.Level.DEBUG:\r\n return 'debug';\r\n case Log.Level.INFO:\r\n return 'info';\r\n case Log.Level.WARNING:\r\n return 'warn';\r\n case Log.Level.ERROR:\r\n return 'error';\r\n case Log.Level.ASSERT:\r\n return 'assert';\r\n default:\r\n return 'unknown';\r\n }\r\n },\r\n\r\n /**\r\n * @param {string|number|Log.Level} v\r\n * @returns {Log.Level}\r\n */\r\n get: function (v) {\r\n if (typeof v === 'number') return /** @type {Log.Level} */ v;\r\n if (!isNaN(parseInt(v))) return /** @type {Log.Level} */ parseInt(v);\r\n switch (v.toLowerCase()) {\r\n case 't':\r\n case 'trace':\r\n return Log.Level.TRACE;\r\n case 'v':\r\n case 'verbose':\r\n return Log.Level.VERBOSE;\r\n case 'd':\r\n case 'debug':\r\n return Log.Level.DEBUG;\r\n case 'i':\r\n case 'info':\r\n return Log.Level.INFO;\r\n case 'w':\r\n case 'warn':\r\n case 'warning':\r\n return Log.Level.WARNING;\r\n case 'e':\r\n case 'error':\r\n case 'exception':\r\n return Log.Level.ERROR;\r\n case 'a':\r\n case 'assert':\r\n case 'assertion':\r\n return Log.Level.ASSERT;\r\n }\r\n return /** @type {Log.Level} */ 0;\r\n }\r\n};\r\nLog.TRACE = Log.Level.TRACE;\r\nLog.VERBOSE = Log.Level.VERBOSE;\r\nLog.DEBUG = Log.Level.DEBUG;\r\nLog.INFO = Log.Level.INFO;\r\nLog.WARNING = Log.Level.WARNING;\r\nLog.ERROR = Log.Level.ERROR;\r\nLog.ASSERT = Log.Level.ASSERT;\r\nLog._instance = null;\r\n\r\nLog.d.tag = (tag) => Log.d.bind(null, tag);\r\nLog.e.tag = (tag) => Log.e.bind(null, tag);\r\nLog.i.tag = (tag) => Log.i.bind(null, tag);\r\nLog.v.tag = (tag) => Log.v.bind(null, tag);\r\nLog.w.tag = (tag) => Log.w.bind(null, tag);\r\nLog.t.tag = (tag) => Log.t.bind(null, tag);\r\n\r\nClass.register(Log);\r\n","/**\r\n * @interface\r\n */\r\nclass IWorker {\r\n static async createProxy(clazz, name, worker) {\r\n return new (IWorker.Proxy(clazz))(worker, name);\r\n }\r\n\r\n static async startWorkerForProxy(clazz, name, workerScript) {\r\n if (!IWorker._workersSupported) {\r\n await IWorker._workerImplementation[clazz.name].init(name);\r\n return IWorker._workerImplementation[clazz.name];\r\n } else {\r\n if (!workerScript) {\r\n workerScript = `${Krypton._path}worker.js`;\r\n }\r\n return IWorker.createProxy(clazz, name, new Worker(URL.createObjectURL(new Blob([`Krypton = {_path: '${Krypton._path}'}; importScripts('${workerScript.replace(/'/g, '')}');`]))));\r\n }\r\n }\r\n\r\n static async startWorkerPoolForProxy(clazz, name, size, workerScript) {\r\n return (new (IWorker.Pool(clazz))((name) => IWorker.startWorkerForProxy(clazz, name, workerScript), name, size)).start();\r\n }\r\n\r\n static async stubBaseOnMessage(msg) {\r\n try {\r\n if (msg.data.command === 'init') {\r\n if (IWorker._workerImplementation[msg.data.args[0]]) {\r\n const res = await IWorker._workerImplementation[msg.data.args[0]].init(msg.data.args[1]);\r\n self.postMessage({status: 'OK', result: res, id: msg.data.id});\r\n } else {\r\n self.postMessage({status: 'error', result: 'Unknown worker!', id: msg.data.id});\r\n }\r\n } else {\r\n self.postMessage({status: 'error', result: 'Worker not yet initialized!', id: msg.data.id});\r\n }\r\n } catch (e) {\r\n self.postMessage({status: 'error', result: e, id: msg.data.id});\r\n }\r\n }\r\n\r\n static get _workersSupported() {\r\n return typeof Worker !== 'undefined';\r\n }\r\n\r\n static get areWorkersAsync() {\r\n return IWorker._workersSupported;\r\n }\r\n\r\n static get _insideWebWorker() {\r\n return typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;\r\n }\r\n\r\n static get _global() {\r\n return typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : null;\r\n }\r\n\r\n static prepareForWorkerUse(baseClazz, impl) {\r\n if (IWorker._insideWebWorker) {\r\n // Only inside WebWorker\r\n self.onmessage = IWorker.stubBaseOnMessage;\r\n }\r\n IWorker._workerImplementation = IWorker._workerImplementation || {};\r\n IWorker._workerImplementation[baseClazz.name] = impl;\r\n }\r\n\r\n static _loadBrowserScript(url, resolve) {\r\n // Adding the script tag to the head as suggested before\r\n const head = document.getElementsByTagName('head')[0];\r\n const script = document.createElement('script');\r\n script.type = 'text/javascript';\r\n script.src = url;\r\n\r\n // Then bind the event to the callback function.\r\n // There are several events for cross browser compatibility.\r\n // These events might occur before processing, so delay them a bit.\r\n const ret = () => setTimeout(resolve, 100);\r\n script.onreadystatechange = ret;\r\n script.onload = ret;\r\n\r\n // Fire the loading\r\n head.appendChild(script);\r\n }\r\n\r\n static Proxy(clazz) {\r\n const proxyClass = class extends clazz {\r\n /**\r\n * @param {Worker} worker\r\n * @param {string} [name]\r\n */\r\n constructor(worker, name) {\r\n super();\r\n this._name = name;\r\n this._messageId = 0;\r\n this._worker = worker;\r\n this._worker.onmessage = this._receive.bind(this);\r\n /** @type {Map.<number,{resolve:Function,error:Function}>} */\r\n this._waiting = new Map();\r\n return this._invoke('init', [clazz.name, name]).then(() => { return this; });\r\n }\r\n\r\n _receive(msg) {\r\n const cb = this._waiting.get(msg.data.id);\r\n if (!cb) {\r\n Log.w(WorkerProxy, 'Unknown reply', msg);\r\n } else {\r\n this._waiting.delete(msg.data.id);\r\n if (msg.data.status === 'OK') {\r\n cb.resolve(msg.data.result);\r\n } else if (msg.data.status === 'error') {\r\n cb.error(msg.data.result);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {string} command\r\n * @param {object[]} [args]\r\n * @returns {Promise}\r\n * @private\r\n */\r\n _invoke(command, args = []) {\r\n return new Promise((resolve, error) => {\r\n const obj = {command: command, args: args, id: this._messageId++};\r\n this._waiting.set(obj.id, {resolve, error});\r\n this._worker.postMessage(obj);\r\n });\r\n }\r\n\r\n destroy() {\r\n return this._invoke('destroy');\r\n }\r\n };\r\n for (const funcName of Object.getOwnPropertyNames(clazz.prototype)) {\r\n if (typeof clazz.prototype[funcName] === 'function' && funcName !== 'constructor') {\r\n proxyClass.prototype[funcName] = function (...args) {\r\n return this._invoke(funcName, args);\r\n };\r\n }\r\n }\r\n return proxyClass;\r\n }\r\n\r\n /**\r\n * @param {object} clazz\r\n * @return {Stub}\r\n * @constructor\r\n */\r\n static Stub(clazz) {\r\n const Stub = class extends clazz {\r\n constructor() {\r\n super();\r\n }\r\n\r\n _result(msg, status, result) {\r\n self.postMessage({status, result, id: msg.data.id});\r\n }\r\n\r\n _onmessage(msg) {\r\n try {\r\n const res = this._invoke(msg.data.command, msg.data.args);\r\n if (res instanceof Promise) {\r\n res.then((finalRes) => { this._result(msg, 'OK', finalRes); });\r\n } else {\r\n this._result(msg, 'OK', res);\r\n }\r\n } catch (e) {\r\n this._result(msg, 'error', e.message || e);\r\n }\r\n }\r\n\r\n init(name) {\r\n this._name = name;\r\n if (IWorker._insideWebWorker) {\r\n self.name = name;\r\n self.onmessage = (msg) => this._onmessage(msg);\r\n }\r\n }\r\n\r\n _invoke(command, args) {\r\n return this[command].apply(this, args);\r\n }\r\n\r\n destroy() {\r\n if (IWorker._insideWebWorker) {\r\n self.close();\r\n }\r\n }\r\n };\r\n for (const funcName of Object.getOwnPropertyNames(clazz.prototype)) {\r\n if (typeof clazz.prototype[funcName] === 'function' && funcName !== 'constructor') {\r\n Stub.prototype[funcName] = function () {\r\n throw `Not implemented in IWorker Stub: ${funcName}`;\r\n };\r\n }\r\n }\r\n return Stub;\r\n }\r\n\r\n static Pool(clazz) {\r\n const poolClass = class extends clazz {\r\n /**\r\n *\r\n * @param {function(string):Promise} proxyInitializer\r\n * @param {string} [name]\r\n * @param {number} [size] Number of workers in this pool.\r\n */\r\n constructor(proxyInitializer, name = 'pool', size = 1) {\r\n super();\r\n /** @type {function(string):Promise} */\r\n this._proxyInitializer = proxyInitializer;\r\n /** @type {string} */\r\n this._name = name;\r\n /** @type {number} */\r\n this._poolSize = size;\r\n /** @type {Array} */\r\n this._workers = [];\r\n /** @type {Array} */\r\n this._freeWorkers = [];\r\n /** @type {Array.<{name:string, args:Array, resolve:function, error:function}>} */\r\n this._waitingCalls = [];\r\n }\r\n\r\n async start() {\r\n await this._updateToSize();\r\n\r\n return this;\r\n }\r\n\r\n get poolSize() {\r\n return this._poolSize;\r\n }\r\n\r\n set poolSize(_size) {\r\n this._poolSize = _size;\r\n this._updateToSize().catch(Log.w.tag(IWorker));\r\n }\r\n\r\n destroy() {\r\n this._poolSize = 0;\r\n return this._updateToSize();\r\n }\r\n\r\n /**\r\n * @param {string} name Name of the function to call on a worker\r\n * @param {Array} args Arguments to pass to the function\r\n * @returns {Promise}\r\n */\r\n _invoke(name, args) {\r\n if (IWorker._workersSupported) {\r\n return new Promise((resolve, error) => {\r\n this._waitingCalls.push({name, args, resolve, error});\r\n const worker = this._freeWorkers.shift();\r\n if (worker) {\r\n this._step(worker).catch(Log.w.tag(IWorker));\r\n }\r\n });\r\n } else {\r\n return this._workers[0][name].apply(this._workers[0], args);\r\n }\r\n }\r\n\r\n /**\r\n * @param worker\r\n * @returns {Promise.<void>}\r\n * @private\r\n */\r\n async _step(worker) {\r\n let call = this._waitingCalls.shift();\r\n while (call) {\r\n try {\r\n // eslint-disable-next-line no-await-in-loop\r\n call.resolve(await worker[call.name].apply(worker, call.args));\r\n } catch (e) {\r\n call.error(e);\r\n }\r\n if (this._workers.indexOf(worker) === -1) {\r\n worker.destroy();\r\n return;\r\n }\r\n call = this._waitingCalls.shift();\r\n }\r\n this._freeWorkers.push(worker);\r\n }\r\n\r\n async _updateToSize() {\r\n if (typeof Worker === 'undefined' && this._poolSize > 1) {\r\n Log.d(IWorker, 'Pool of size larger than 1 requires WebWorker support.');\r\n this._poolSize = 1;\r\n }\r\n\r\n const workerPromises = [];\r\n while (this._workers.length + workerPromises.length < this._poolSize) {\r\n workerPromises.push(this._proxyInitializer(`${this._name}#${this._workers.length + workerPromises.length}`));\r\n }\r\n const createdWorkers = await Promise.all(workerPromises);\r\n for (const worker of createdWorkers) {\r\n this._workers.push(worker);\r\n this._step(worker).catch(Log.w.tag(IWorker));\r\n }\r\n\r\n while (this._workers.length > this._poolSize) {\r\n const worker = this._freeWorkers.shift() || this._workers.pop();\r\n const idx = this._workers.indexOf(worker);\r\n if (idx >= 0) {\r\n // This was a free worker, also remove it from the worker list and destroy it now.\r\n this._workers.splice(idx, 1);\r\n worker.destroy();\r\n }\r\n }\r\n return this;\r\n }\r\n };\r\n for (const funcName of Object.getOwnPropertyNames(clazz.prototype)) {\r\n if (typeof clazz.prototype[funcName] === 'function' && funcName !== 'constructor') {\r\n poolClass.prototype[funcName] = function (...args) {\r\n return this._invoke(funcName, args);\r\n };\r\n }\r\n }\r\n return poolClass;\r\n }\r\n}\r\n\r\nIWorker._moduleLoadedCallbacks = {};\r\nIWorker._workerImplementation = {};\r\nClass.register(IWorker);\r\n","class CryptoUtils {\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} data\r\n * @return {Uint8Array}\r\n */\r\n static computeHmacSha512(key, data) {\r\n if (key.length > CryptoUtils.SHA512_BLOCK_SIZE) {\r\n key = new SerialBuffer(Hash.computeSha512(key));\r\n }\r\n\r\n const iKey = new SerialBuffer(CryptoUtils.SHA512_BLOCK_SIZE);\r\n const oKey = new SerialBuffer(CryptoUtils.SHA512_BLOCK_SIZE);\r\n for (let i = 0; i < CryptoUtils.SHA512_BLOCK_SIZE; ++i) {\r\n const byte = key[i] || 0;\r\n iKey[i] = 0x36 ^ byte;\r\n oKey[i] = 0x5c ^ byte;\r\n }\r\n\r\n const innerHash = Hash.computeSha512(BufferUtils.concatTypedArrays(iKey, data));\r\n return Hash.computeSha512(BufferUtils.concatTypedArrays(oKey, innerHash));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} password\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @param {number} derivedKeyLength\r\n * @return {SerialBuffer}\r\n */\r\n static computePBKDF2sha512(password, salt, iterations, derivedKeyLength) {\r\n // Following https://www.ietf.org/rfc/rfc2898.txt\r\n const hashLength = Hash.SIZE.get(Hash.Algorithm.SHA512);\r\n\r\n if (derivedKeyLength > (Math.pow(2, 32) - 1) * hashLength) {\r\n throw new Error('Derived key too long');\r\n }\r\n\r\n const l = Math.ceil(derivedKeyLength / hashLength);\r\n const r = derivedKeyLength - (l - 1) * hashLength;\r\n\r\n const derivedKey = new SerialBuffer(derivedKeyLength);\r\n for (let i = 1; i <= l; i++) {\r\n let u = new SerialBuffer(salt.length + 4);\r\n u.write(salt);\r\n u.writeUint32(i);\r\n\r\n u = CryptoUtils.computeHmacSha512(password, u);\r\n const t = u;\r\n for (let j = 1; j < iterations; j++) {\r\n u = CryptoUtils.computeHmacSha512(password, u);\r\n for (let k = 0; k < t.length; k++) {\r\n t[k] ^= u[k];\r\n }\r\n }\r\n\r\n if (i < l) {\r\n derivedKey.write(t);\r\n } else {\r\n derivedKey.write(t.slice(0, r));\r\n }\r\n }\r\n return derivedKey;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} message\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @return {Promise.<Uint8Array>}\r\n * @deprecated\r\n */\r\n static async otpKdfLegacy(message, key, salt, iterations) {\r\n const worker = await CryptoWorker.getInstanceAsync();\r\n const derivedKey = await worker.kdfLegacy(key, salt, iterations, message.byteLength);\r\n return BufferUtils.xor(message, derivedKey);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} message\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @return {Promise.<Uint8Array>}\r\n */\r\n static async otpKdf(message, key, salt, iterations) {\r\n const worker = await CryptoWorker.getInstanceAsync();\r\n const derivedKey = await worker.kdf(key, salt, iterations, message.byteLength);\r\n return BufferUtils.xor(message, derivedKey);\r\n }\r\n\r\n}\r\nCryptoUtils.SHA512_BLOCK_SIZE = 128;\r\n\r\nClass.register(CryptoUtils);\r\n","/**\r\n * @interface\r\n */\r\nclass CryptoWorker {\r\n static get lib() { return CryptoLib.instance; }\r\n\r\n /**\r\n * @returns {Promise.<CryptoWorker>}\r\n */\r\n static async getInstanceAsync() {\r\n if (!CryptoWorker._workerAsync) {\r\n CryptoWorker._workerAsync = await IWorker.startWorkerPoolForProxy(CryptoWorker, 'crypto', 4);\r\n }\r\n return CryptoWorker._workerAsync;\r\n }\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Promise.<Uint8Array>}\r\n */\r\n async computeArgon2d(input) {}\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} inputs\r\n * @returns {Promise.<Array.<Uint8Array>>}\r\n */\r\n async computeArgon2dBatch(inputs) {}\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @param {number} outputSize\r\n * @returns {Promise.<Uint8Array>}\r\n * @deprecated\r\n */\r\n async kdfLegacy(key, salt, iterations, outputSize) {}\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @param {number} outputSize\r\n * @returns {Promise.<Uint8Array>}\r\n */\r\n async kdf(key, salt, iterations, outputSize) {}\r\n\r\n /**\r\n * @param {Uint8Array} block\r\n * @param {Array.<bool>} transactionValid\r\n * @param {number} timeNow\r\n * @param {Uint8Array} genesisHash\r\n * @param {number} networkId\r\n * @returns {Promise.<{valid: boolean, pow: SerialBuffer, interlinkHash: SerialBuffer, bodyHash: SerialBuffer}>}\r\n */\r\n async blockVerify(block, transactionValid, timeNow, genesisHash, networkId) {}\r\n}\r\n/** @type {CryptoWorker} */\r\nCryptoWorker._workerAsync = null;\r\n\r\nClass.register(CryptoWorker);\r\n","class CryptoWorkerImpl extends IWorker.Stub(CryptoWorker) {\r\n constructor() {\r\n super();\r\n // FIXME: This is needed for Babel to work correctly. Can be removed as soon as we updated to Babel v7.\r\n this._superInit = super.init;\r\n }\r\n\r\n async init(name) {\r\n await this._superInit.call(this, name);\r\n if (PlatformUtils.isBrowser()) await WasmHelper.doImportBrowser();\r\n CryptoWorker._workerAsync = this;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n computeArgon2d(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.ARGON2D));\r\n const res = NodeNative.node_argon2(out, new Uint8Array(input), 512);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.ARGON2D);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n const res = Module._krypton_argon2(wasmOut, wasmIn, input.length, 512);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(CryptoWorkerImpl, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} inputs\r\n * @returns {Array.<Uint8Array>}\r\n */\r\n computeArgon2dBatch(inputs) {\r\n const hashes = [];\r\n if (PlatformUtils.isNodeJs()) {\r\n for(const input of inputs) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.ARGON2D));\r\n const res = NodeNative.node_argon2(out, new Uint8Array(input), 512);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n hashes.push(out);\r\n }\r\n return hashes;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.ARGON2D);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const stackTmp = Module.stackSave();\r\n for (const input of inputs) {\r\n Module.stackRestore(stackTmp);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n const res = Module._krypton_argon2(wasmOut, wasmIn, input.length, 512);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n hashes.push(hash);\r\n }\r\n return hashes;\r\n } catch (e) {\r\n Log.w(CryptoWorkerImpl, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @param {number} outputSize\r\n * @returns {Uint8Array}\r\n * @deprecated\r\n */\r\n kdfLegacy(key, salt, iterations, outputSize = Hash.getSize(Hash.Algorithm.ARGON2D)) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(outputSize);\r\n const res = NodeNative.node_kdf_legacy(out, new Uint8Array(key), new Uint8Array(salt), 512, iterations);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOut = Module.stackAlloc(outputSize);\r\n const wasmIn = Module.stackAlloc(key.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, key.length).set(key);\r\n const wasmSalt = Module.stackAlloc(salt.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmSalt, salt.length).set(salt);\r\n const res = Module._krypton_kdf_legacy(wasmOut, outputSize, wasmIn, key.length, wasmSalt, salt.length, 512, iterations);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n const hash = new Uint8Array(outputSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, outputSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(CryptoWorkerImpl, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} key\r\n * @param {Uint8Array} salt\r\n * @param {number} iterations\r\n * @param {number} outputSize\r\n * @returns {Uint8Array}\r\n */\r\n kdf(key, salt, iterations, outputSize = Hash.getSize(Hash.Algorithm.ARGON2D)) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(outputSize);\r\n const res = NodeNative.node_kdf(out, new Uint8Array(key), new Uint8Array(salt), 512, iterations);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOut = Module.stackAlloc(outputSize);\r\n const wasmIn = Module.stackAlloc(key.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, key.length).set(key);\r\n const wasmSalt = Module.stackAlloc(salt.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmSalt, salt.length).set(salt);\r\n const res = Module._krypton_kdf(wasmOut, outputSize, wasmIn, key.length, wasmSalt, salt.length, 512, iterations);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n const hash = new Uint8Array(outputSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, outputSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(CryptoWorkerImpl, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} blockSerialized\r\n * @param {Array.<boolean|undefined>} transactionValid\r\n * @param {number} timeNow\r\n * @param {Uint8Array} genesisHash\r\n * @param {number} networkId\r\n * @returns {Promise.<{valid: boolean, pow: SerialBuffer, interlinkHash: SerialBuffer, bodyHash: SerialBuffer}>}\r\n */\r\n async blockVerify(blockSerialized, transactionValid, timeNow, genesisHash, networkId) {\r\n // The worker only uses a stub genesis config.\r\n GenesisConfig = {\r\n GENESIS_HASH: Hash.unserialize(new SerialBuffer(genesisHash)),\r\n NETWORK_ID: networkId\r\n };\r\n\r\n const block = Block.unserialize(new SerialBuffer(blockSerialized));\r\n for (let i = 0; i < transactionValid.length; i++) {\r\n block.body.transactions[i]._valid = transactionValid[i];\r\n }\r\n\r\n const valid = await block._verify(timeNow);\r\n const pow = await block.header.pow();\r\n const interlinkHash = block.interlink.hash();\r\n const bodyHash = block.body.hash();\r\n return { valid: valid, pow: pow.serialize(), interlinkHash: interlinkHash.serialize(), bodyHash: bodyHash.serialize() };\r\n }\r\n}\r\n\r\nIWorker.prepareForWorkerUse(CryptoWorker, new CryptoWorkerImpl());\r\n",";(function (globalObject) {\r\n 'use strict';\r\n\r\n /*\r\n * bignumber.js v7.0.1\r\n * A JavaScript library for arbitrary-precision arithmetic.\r\n * https://github.com/MikeMcl/bignumber.js\r\n * Copyright (c) 2018 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 |\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\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 decimalSeparator: '.',\r\n groupSeparator: ',',\r\n groupSize: 3,\r\n secondaryGroupSize: 0,\r\n fractionGroupSeparator: '\\xA0', // non-breaking space\r\n fractionGroupSize: 0\r\n },\r\n\r\n // The alphabet used for base conversion.\r\n // It must be at least 2 characters long, with no '.' 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 * n {number|string|BigNumber} A numeric value.\r\n * [b] {number} The base of n. Integer, 2 to ALPHABET.length inclusive.\r\n */\r\n function BigNumber(n, b) {\r\n var alphabet, c, e, i, isNum, len, str,\r\n x = this;\r\n\r\n // Enable constructor usage without new.\r\n if (!(x instanceof BigNumber)) {\r\n\r\n // Don't throw on constructor call without new (#81).\r\n // '[BigNumber Error] Constructor call without new: {n}'\r\n //throw Error(bignumberError + ' Constructor call without new: ' + n);\r\n return new BigNumber(n, b);\r\n }\r\n\r\n if (b == null) {\r\n\r\n // Duplicate.\r\n if (n instanceof BigNumber) {\r\n x.s = n.s;\r\n x.e = n.e;\r\n x.c = (n = n.c) ? n.slice() : n;\r\n return;\r\n }\r\n\r\n isNum = typeof n == 'number';\r\n\r\n if (isNum && n * 0 == 0) {\r\n\r\n // Use `1 / n` to handle minus zero also.\r\n x.s = 1 / n < 0 ? (n = -n, -1) : 1;\r\n\r\n // Faster path for integers.\r\n if (n === ~~n) {\r\n for (e = 0, i = n; i >= 10; i /= 10, e++);\r\n x.e = e;\r\n x.c = [n];\r\n return;\r\n }\r\n\r\n str = n + '';\r\n } else {\r\n if (!isNumeric.test(str = n + '')) return parseNumeric(x, str, isNum);\r\n x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\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 str = n + '';\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(n instanceof BigNumber ? n : str);\r\n return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n }\r\n\r\n isNum = typeof n == 'number';\r\n\r\n if (isNum) {\r\n\r\n // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n if (n * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n x.s = 1 / n < 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 + n);\r\n }\r\n\r\n // Prevent later check for length on converted number.\r\n isNum = false;\r\n } else {\r\n x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n\r\n // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n if (b > 10 && b < 37) str = str.toLowerCase();\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 }\r\n\r\n return parseNumeric(x, n + '', isNum, b);\r\n }\r\n }\r\n\r\n str = convertBase(str, b, 10, x.s);\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 // 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 str = str.slice(i, ++len);\r\n\r\n if (str) {\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 && (n > MAX_SAFE_INTEGER || n !== mathfloor(n))) {\r\n throw Error\r\n (tooManyDigits + (x.s * n));\r\n }\r\n\r\n e = e - i - 1;\r\n\r\n // Overflow?\r\n if (e > 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;\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 str = str.slice(i);\r\n i = LOG_BASE - str.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, and not\r\n * containing '.'. The empty string, null or undefined\r\n * resets the alphabet to its default value.\r\n * FORMAT {object} An object with some of the following properties:\r\n * decimalSeparator {string}\r\n * groupSeparator {string}\r\n * groupSize {number}\r\n * secondaryGroupSize {number}\r\n * fractionGroupSeparator {string}\r\n * fractionGroupSize {number}\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 (isArray(v)) {\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 (isArray(v)) {\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 only one character, or contains '.' or a repeated character.\r\n if (typeof v == 'string' && !/^.$|\\.|(.).*\\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 * v {any}\r\n */\r\n BigNumber.isBigNumber = function (v) {\r\n return v instanceof BigNumber || v && v._isBigNumber === true || false;\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 // 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))\r\n : 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\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 m, n,\r\n i = 0;\r\n\r\n if (isArray(args[0])) args = args[0];\r\n m = new BigNumber(args[0]);\r\n\r\n for (; ++i < args.length;) {\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 x.c = x.e = null;\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.c = x.e = x.s = null;\r\n }\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 // 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, 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: ' + 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(+x.valueOf(), nIsBig ? 2 - isOdd(n) : +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 nIsOdd = isOdd(n);\r\n } else {\r\n nIsOdd = n % 2;\r\n }\r\n\r\n if (nIsNeg) n.s = 1;\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 (nIsBig) {\r\n n = n.times(half);\r\n round(n, n.e + 1, 1);\r\n if (!n.c[0]) break;\r\n nIsBig = n.e > 14;\r\n nIsOdd = isOdd(n);\r\n } else {\r\n n = mathfloor(n / 2);\r\n if (!n) break;\r\n nIsOdd = n % 2;\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 = P.equals = 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(+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 = '1e' + 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 =\r\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 object (see BigNumber.set).\r\n *\r\n * FORMAT = {\r\n * decimalSeparator : '.',\r\n * groupSeparator : ',',\r\n * groupSize : 3,\r\n * secondaryGroupSize : 0,\r\n * fractionGroupSeparator : '\\xA0', // non-breaking space\r\n * fractionGroupSize : 0\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 *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\r\n P.toFormat = function (dp, rm) {\r\n var str = this.toFixed(dp, rm);\r\n\r\n if (this.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 = this.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\r\n for (; i < len; i += g1) {\r\n intPart += groupSeparator + intDigits.substr(i, g1);\r\n }\r\n\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 str;\r\n };\r\n\r\n\r\n /*\r\n * Return a string array representing the value of this BigNumber as a simple fraction with\r\n * an integer numerator and an integer denominator. The denominator will be a positive\r\n * non-zero value less than or equal to the specified maximum denominator. If a maximum\r\n * denominator is not specified, the denominator will be the lowest value necessary to\r\n * 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 arr, d, d0, d1, d2, e, exp, n, n0, n1, q, 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: ') + md);\r\n }\r\n }\r\n\r\n if (!xc) return x.toString();\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 *= 2;\r\n\r\n // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n arr = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1\r\n ? [n1.toString(), d1.toString()]\r\n : [n0.toString(), d0.toString()];\r\n\r\n MAX_EXP = exp;\r\n return arr;\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 +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\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 str = coeffToString(n.c);\r\n\r\n if (b == null) {\r\n str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n ? toExponential(str, e)\r\n : toFixedPoint(str, e, '0');\r\n } else {\r\n intCheck(b, 2, ALPHABET.length, 'Base');\r\n str = convertBase(toFixedPoint(str, 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 var str,\r\n n = this,\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 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\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 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 !== (n < 0 ? mathceil(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: ') + n);\r\n }\r\n }\r\n\r\n\r\n function isArray(obj) {\r\n return Object.prototype.toString.call(obj) == '[object Array]';\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 globalObject.BigNumber = BigNumber;\r\n})(Class.scope);\r\nconst BigNumber = Class.scope.BigNumber;\r\nBigNumber.config({ DECIMAL_PLACES: 11 });\r\n","class NumberUtils {\r\n /**\r\n * @param {unknown} val\r\n * @return {boolean}\r\n */\r\n static isUint8(val) {\r\n return Number.isInteger(val)\r\n && val >= 0 && val <= NumberUtils.UINT8_MAX;\r\n }\r\n\r\n /**\r\n * @param {unknown} val\r\n * @return {boolean}\r\n */\r\n static isUint16(val) {\r\n return Number.isInteger(val)\r\n && val >= 0 && val <= NumberUtils.UINT16_MAX;\r\n }\r\n\r\n /**\r\n * @param {unknown} val\r\n * @return {boolean}\r\n */\r\n static isUint32(val) {\r\n return Number.isInteger(val)\r\n && val >= 0 && val <= NumberUtils.UINT32_MAX;\r\n }\r\n\r\n /**\r\n * @param {unknown} val\r\n * @return {boolean}\r\n */\r\n static isUint64(val) {\r\n return Number.isInteger(val)\r\n && val >= 0 && val <= NumberUtils.UINT64_MAX;\r\n }\r\n\r\n /**\r\n * @param {BigNumber} val\r\n * @return {boolean}\r\n */\r\n static isUint128(val) {\r\n return val.isInteger() && val.gte(0) && val.lte(NumberUtils.UINT128_MAX);\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n static randomUint32() {\r\n return Math.floor(Math.random() * (NumberUtils.UINT32_MAX + 1));\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n static randomUint64() {\r\n return Math.floor(Math.random() * (NumberUtils.UINT64_MAX + 1));\r\n }\r\n\r\n /**\r\n * @param {string} bin\r\n * @return {number}\r\n */\r\n static fromBinary(bin) {\r\n return parseInt(bin, 2);\r\n }\r\n}\r\n\r\nNumberUtils.UINT8_MAX = 255;\r\nNumberUtils.UINT16_MAX = 65535;\r\nNumberUtils.UINT32_MAX = 4294967295;\r\nNumberUtils.UINT64_MAX = Number.MAX_SAFE_INTEGER;\r\nNumberUtils.UINT128_MAX = new BigNumber('ffffffffffffffffffffffffffffffff', 16);\r\n//Object.freeze(NumberUtils);\r\nClass.register(NumberUtils);\r\n","class BufferUtils {\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toAscii(buffer) {\r\n const chunkSize = 0x2000;\r\n const buf = BufferUtils._toUint8View(buffer);\r\n\r\n let ascii = '';\r\n for (let i = 0; i < buf.length; i += chunkSize) {\r\n ascii += String.fromCharCode.apply(null, buf.subarray(i, i + chunkSize));\r\n }\r\n return ascii;\r\n }\r\n\r\n /**\r\n * @param {string} string\r\n * @return {Uint8Array}\r\n */\r\n static fromAscii(string) {\r\n const buf = new Uint8Array(string.length);\r\n for (let i = 0; i < string.length; ++i) {\r\n buf[i] = string.charCodeAt(i);\r\n }\r\n return buf;\r\n }\r\n\r\n static _codePointTextDecoder(buffer) {\r\n if (typeof TextDecoder === 'undefined') throw new Error('TextDecoder not supported');\r\n if (BufferUtils._ISO_8859_15_DECODER === null) throw new Error('TextDecoder does not support iso-8859-15');\r\n if (BufferUtils._ISO_8859_15_DECODER === undefined) {\r\n try {\r\n BufferUtils._ISO_8859_15_DECODER = new TextDecoder('iso-8859-15');\r\n } catch (e) {\r\n BufferUtils._ISO_8859_15_DECODER = null;\r\n throw new Error('TextDecoder does not support iso-8859-15');\r\n }\r\n }\r\n const uint8View = BufferUtils._toUint8View(buffer);\r\n return BufferUtils._ISO_8859_15_DECODER.decode(uint8View)\r\n .replace(/\\u20ac/g, '\\u00a4') // € => ¤\r\n .replace(/\\u0160/g, '\\u00a6') // Š => ¦\r\n .replace(/\\u0161/g, '\\u00a8') // š => ¨\r\n .replace(/\\u017d/g, '\\u00b4') // Ž => ´\r\n .replace(/\\u017e/g, '\\u00b8') // ž => ¸\r\n .replace(/\\u0152/g, '\\u00bc') // Œ => ¼\r\n .replace(/\\u0153/g, '\\u00bd') // œ => ½\r\n .replace(/\\u0178/g, '\\u00be'); // Ÿ => ¾\r\n }\r\n\r\n static _tripletToBase64(num) {\r\n return BufferUtils._BASE64_LOOKUP[num >> 18 & 0x3F] + BufferUtils._BASE64_LOOKUP[num >> 12 & 0x3F] + BufferUtils._BASE64_LOOKUP[num >> 6 & 0x3F] + BufferUtils._BASE64_LOOKUP[num & 0x3F];\r\n }\r\n\r\n static _base64encodeChunk(u8, start, end) {\r\n let tmp;\r\n const output = [];\r\n for (let i = start; i < end; i += 3) {\r\n tmp = ((u8[i] << 16) & 0xFF0000) + ((u8[i + 1] << 8) & 0xFF00) + (u8[i + 2] & 0xFF);\r\n output.push(BufferUtils._tripletToBase64(tmp));\r\n }\r\n return output.join('');\r\n }\r\n\r\n static _base64fromByteArray(u8) {\r\n let tmp;\r\n const len = u8.length;\r\n const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\r\n let output = '';\r\n const parts = [];\r\n const maxChunkLength = 16383; // must be multiple of 3\r\n\r\n // go through the array every three bytes, we'll deal with trailing stuff later\r\n for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\r\n parts.push(BufferUtils._base64encodeChunk(u8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));\r\n }\r\n\r\n // pad the end with zeros, but make sure to not forget the extra bytes\r\n if (extraBytes === 1) {\r\n tmp = u8[len - 1];\r\n output += BufferUtils._BASE64_LOOKUP[tmp >> 2];\r\n output += BufferUtils._BASE64_LOOKUP[(tmp << 4) & 0x3F];\r\n output += '==';\r\n } else if (extraBytes === 2) {\r\n tmp = (u8[len - 2] << 8) + (u8[len - 1]);\r\n output += BufferUtils._BASE64_LOOKUP[tmp >> 10];\r\n output += BufferUtils._BASE64_LOOKUP[(tmp >> 4) & 0x3F];\r\n output += BufferUtils._BASE64_LOOKUP[(tmp << 2) & 0x3F];\r\n output += '=';\r\n }\r\n\r\n parts.push(output);\r\n\r\n return parts.join('');\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toBase64(buffer) {\r\n if (PlatformUtils.isNodeJs()) {\r\n return Buffer.from(buffer).toString('base64');\r\n } else if (typeof TextDecoder !== 'undefined' && BufferUtils._ISO_8859_15_DECODER !== null) {\r\n try {\r\n return btoa(BufferUtils._codePointTextDecoder(buffer));\r\n } catch (e) {\r\n // Disabled itself\r\n }\r\n }\r\n\r\n return BufferUtils._base64fromByteArray(BufferUtils._toUint8View(buffer));\r\n }\r\n\r\n /**\r\n * @param {string} base64\r\n * @param {number} [length]\r\n * @return {SerialBuffer}\r\n */\r\n static fromBase64(base64, length) {\r\n const arr = new Uint8Array(atob(base64).split('').map(c => c.charCodeAt(0)));\r\n if (length !== undefined && arr.length !== length) throw new Error('Decoded length does not match expected length');\r\n return new SerialBuffer(arr);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toBase64Url(buffer) {\r\n return BufferUtils.toBase64(buffer).replace(/\\//g, '_').replace(/\\+/g, '-').replace(/=/g, '.');\r\n }\r\n\r\n /**\r\n * @param {string} base64\r\n * @param {number} [length]\r\n * @return {SerialBuffer}\r\n */\r\n static fromBase64Url(base64, length) {\r\n return BufferUtils.fromBase64(base64.replace(/_/g, '/').replace(/-/g, '+').replace(/\\./g, '='), length);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buf\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {string}\r\n */\r\n static toBase32(buf, alphabet = BufferUtils.BASE32_ALPHABET.KRYPTON) {\r\n let shift = 3, carry = 0, byte, symbol, i, res = '';\r\n\r\n for (i = 0; i < buf.length; i++) {\r\n byte = buf[i];\r\n symbol = carry | (byte >> shift);\r\n res += alphabet[symbol & 0x1f];\r\n\r\n if (shift > 5) {\r\n shift -= 5;\r\n symbol = byte >> shift;\r\n res += alphabet[symbol & 0x1f];\r\n }\r\n\r\n shift = 5 - shift;\r\n carry = byte << shift;\r\n shift = 8 - shift;\r\n }\r\n\r\n if (shift !== 3) {\r\n res += alphabet[carry & 0x1f];\r\n }\r\n\r\n while (res.length % 8 !== 0 && alphabet.length === 33) {\r\n res += alphabet[32];\r\n }\r\n\r\n return res;\r\n }\r\n\r\n /**\r\n * @param {string} base32\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {Uint8Array}\r\n */\r\n static fromBase32(base32, alphabet = BufferUtils.BASE32_ALPHABET.KRYPTON) {\r\n const charmap = [];\r\n alphabet.toUpperCase().split('').forEach((c, i) => {\r\n if (!(c in charmap)) charmap[c] = i;\r\n });\r\n\r\n let symbol, shift = 8, carry = 0, buf = [];\r\n base32.toUpperCase().split('').forEach((char) => {\r\n // ignore padding\r\n if (alphabet.length === 33 && char === alphabet[32]) return;\r\n\r\n symbol = charmap[char] & 0xff;\r\n\r\n shift -= 5;\r\n if (shift > 0) {\r\n carry |= symbol << shift;\r\n } else if (shift < 0) {\r\n buf.push(carry | (symbol >> -shift));\r\n shift += 8;\r\n carry = (symbol << shift) & 0xff;\r\n } else {\r\n buf.push(carry | symbol);\r\n shift = 8;\r\n carry = 0;\r\n }\r\n });\r\n\r\n if (shift !== 8 && carry !== 0) {\r\n buf.push(carry);\r\n }\r\n\r\n return new Uint8Array(buf);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toHex(buffer) {\r\n let hex = '';\r\n for (let i = 0; i < buffer.length; i++) {\r\n const code = buffer[i];\r\n hex += BufferUtils.HEX_ALPHABET[code >>> 4];\r\n hex += BufferUtils.HEX_ALPHABET[code & 0x0F];\r\n }\r\n return hex;\r\n }\r\n\r\n /**\r\n * @param {string} hex\r\n * @param {number} [length]\r\n * @return {SerialBuffer}\r\n */\r\n static fromHex(hex, length) {\r\n hex = hex.trim();\r\n if (!StringUtils.isHexBytes(hex, length)) throw new Error('String is not an hex string (of matching length)');\r\n return new SerialBuffer(new Uint8Array((hex.match(/.{2}/g) || []).map(byte => parseInt(byte, 16))));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buffer\r\n * @return {string}\r\n */\r\n static toBinary(buffer) {\r\n let bin = '';\r\n for (let i = 0; i < buffer.length; i++) {\r\n const code = buffer[i];\r\n bin += StringUtils.lpad(code.toString(2), '0', 8);\r\n }\r\n return bin;\r\n }\r\n\r\n /**\r\n * Taken from https://github.com/google/closure-library/blob/master/closure/goog/crypt/crypt.js.\r\n *\r\n * @param {string} str\r\n * @returns {Uint8Array}\r\n * @private\r\n */\r\n static _strToUint8Array(str) {\r\n const out = [];\r\n let p = 0;\r\n for (let i = 0; i < str.length; i++) {\r\n let c = str.charCodeAt(i);\r\n if (c < 128) {\r\n out[p++] = c;\r\n } else if (c < 2048) {\r\n out[p++] = (c >> 6) | 192;\r\n out[p++] = (c & 63) | 128;\r\n } else if (\r\n ((c & 0xFC00) === 0xD800) && (i + 1) < str.length &&\r\n ((str.charCodeAt(i + 1) & 0xFC00) === 0xDC00)) {\r\n // Surrogate Pair\r\n c = 0x10000 + ((c & 0x03FF) << 10) + (str.charCodeAt(++i) & 0x03FF);\r\n out[p++] = (c >> 18) | 240;\r\n out[p++] = ((c >> 12) & 63) | 128;\r\n out[p++] = ((c >> 6) & 63) | 128;\r\n out[p++] = (c & 63) | 128;\r\n } else {\r\n out[p++] = (c >> 12) | 224;\r\n out[p++] = ((c >> 6) & 63) | 128;\r\n out[p++] = (c & 63) | 128;\r\n }\r\n }\r\n return new Uint8Array(out);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {Uint8Array}\r\n * @private\r\n */\r\n static _utf8TextEncoder(str) {\r\n if (typeof TextEncoder === 'undefined') throw new Error('TextEncoder not supported');\r\n if (BufferUtils._UTF8_ENCODER === null) throw new Error('TextEncoder does not support utf8');\r\n if (BufferUtils._UTF8_ENCODER === undefined) {\r\n try {\r\n BufferUtils._UTF8_ENCODER = new TextEncoder();\r\n } catch (e) {\r\n BufferUtils._UTF8_ENCODER = null;\r\n throw new Error('TextEncoder does not support utf8');\r\n }\r\n }\r\n return BufferUtils._UTF8_ENCODER.encode(str);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {Uint8Array}\r\n */\r\n static fromUtf8(str) {\r\n if (PlatformUtils.isNodeJs()) {\r\n return Buffer.from(str);\r\n } else if (typeof TextEncoder !== 'undefined' && BufferUtils._UTF8_ENCODER !== null) {\r\n try {\r\n return BufferUtils._utf8TextEncoder(str);\r\n } catch (e) {\r\n // Disabled itself\r\n }\r\n }\r\n return BufferUtils._strToUint8Array(str);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array|string} o\r\n * @param {number} [length]\r\n * @return {SerialBuffer}\r\n */\r\n static fromAny(o, length) {\r\n if (o === '') return SerialBuffer.EMPTY;\r\n if (!o) throw new Error('Invalid buffer format');\r\n if (o instanceof Uint8Array) return new SerialBuffer(o);\r\n try {\r\n return BufferUtils.fromHex(o, length);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n try {\r\n return BufferUtils.fromBase64(o, length);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n throw new Error('Invalid buffer format');\r\n }\r\n\r\n\r\n /**\r\n * @template T\r\n * @param {T} a\r\n * @param {*} b\r\n * @return {T}\r\n */\r\n static concatTypedArrays(a, b) {\r\n const c = new (a.constructor)(a.length + b.length);\r\n c.set(a, 0);\r\n c.set(b, a.length);\r\n return c;\r\n }\r\n\r\n /**\r\n * @param {TypedArray} a\r\n * @param {TypedArray} b\r\n * @return {boolean}\r\n */\r\n static equals(a, b) {\r\n const viewA = BufferUtils._toUint8View(a);\r\n const viewB = BufferUtils._toUint8View(b);\r\n if (viewA.length !== viewB.length) return false;\r\n for (let i = 0; i < viewA.length; i++) {\r\n if (viewA[i] !== viewB[i]) return false;\r\n }\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {TypedArray} a\r\n * @param {TypedArray} b\r\n * @return {number} -1 if a is smaller than b, 1 if a is larger than b, 0 if a equals b.\r\n */\r\n static compare(a, b) {\r\n if (a.length < b.length) return -1;\r\n if (a.length > b.length) return 1;\r\n for (let i = 0; i < a.length; i++) {\r\n if (a[i] < b[i]) return -1;\r\n if (a[i] > b[i]) return 1;\r\n }\r\n return 0;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} a\r\n * @param {Uint8Array} b\r\n * @return {Uint8Array}\r\n */\r\n static xor(a, b) {\r\n const res = new Uint8Array(a.byteLength);\r\n for (let i = 0; i < a.byteLength; ++i) {\r\n res[i] = a[i] ^ b[i];\r\n }\r\n return res;\r\n }\r\n\r\n /**\r\n * @param {TypedArray|ArrayBuffer} arrayLike\r\n * @return {Uint8Array}\r\n * @private\r\n */\r\n static _toUint8View(arrayLike) {\r\n if (arrayLike instanceof Uint8Array) {\r\n return arrayLike;\r\n } else if (arrayLike instanceof ArrayBuffer) {\r\n return new Uint8Array(arrayLike);\r\n } else if (arrayLike.buffer instanceof ArrayBuffer) {\r\n return new Uint8Array(arrayLike.buffer);\r\n } else {\r\n throw new Error('TypedArray or ArrayBuffer required');\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buf\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {string}\r\n */\r\n static toBase58(buf, alphabet = BufferUtils.BASE58_ALPHABET) {\r\n let encode = [];\r\n let strOutput = '';\r\n let i = 0, j;\r\n\r\n // case of leading zero.\r\n for (; i < buf.length; i++) {\r\n if (buf[i]) {\r\n break;\r\n } else {\r\n strOutput += alphabet[0];\r\n }\r\n }\r\n\r\n for (; i < buf.length; i++) {\r\n let carry = buf[i];\r\n j = 0;\r\n while (j in encode || carry) {\r\n let n = encode[j] ? (encode[j] << 8) + carry : carry;\r\n carry = n / 58 | 0;\r\n encode[j] = n % 58;\r\n j++;\r\n }\r\n }\r\n\r\n while (j--) {\r\n strOutput += alphabet[encode[j]];\r\n }\r\n\r\n return strOutput;\r\n }\r\n\r\n /**\r\n * @param {string} base58\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {Uint8Array}\r\n */\r\n static fromBase58(base58, alphabet = BufferUtils.BASE58_ALPHABET) {\r\n let bOutput = [];\r\n let decode = [];\r\n let i = 0, j;\r\n\r\n for (; i < base58.length; i++) {\r\n if (alphabet.indexOf(base58[i])) {\r\n break;\r\n } else {\r\n bOutput.push(0);\r\n }\r\n }\r\n\r\n for (; i < base58.length; i++) {\r\n let carry = alphabet.indexOf(base58[i]);\r\n if (carry < 0) return '';\r\n j = 0;\r\n while (j in decode || carry) {\r\n let n = decode[j] ? decode[j] * 58 + carry: carry;\r\n carry = n >> 8;\r\n decode[j] = n % 256;\r\n j++;\r\n }\r\n }\r\n\r\n while (j--) {\r\n bOutput.push(decode[j]);\r\n }\r\n\r\n return new Uint8Array(bOutput);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} buf\r\n * @param {number} [prefix] 0x80 for private key, 0x00 for address\r\n * @param {number} [suffix] 0x01 for private key\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {string}\r\n */\r\n static toBase58Check(buf, prefix = 0x80, suffix, alphabet = BufferUtils.BASE58_ALPHABET) {\r\n let input;\r\n if (suffix) input = new SerialBuffer([prefix & 0xff, ...buf, suffix & 0xff])\r\n else input = new SerialBuffer([prefix & 0xff, ...buf]);\r\n const checksum = Hash.computeSha256(Hash.computeSha256(input)).subarray(0, 4);\r\n const buffer = new SerialBuffer([...input, ...checksum]);\r\n return BufferUtils.toBase58(buffer, alphabet);\r\n }\r\n\r\n /**\r\n * @param {string} base58\r\n * @param {string} [hasSuffix] encoded with suffix\r\n * @param {string} [alphabet] Alphabet to use\r\n * @return {Uint8Array}\r\n */\r\n static fromBase58Check(base58, hasSuffix = false, alphabet = BufferUtils.BASE58_ALPHABET) {\r\n const output = BufferUtils.fromBase58(base58, alphabet);\r\n // skip the first byte of prefix and the last bytes of suffix and checksum\r\n const end = hasSuffix ? -5 : -4\r\n return new Uint8Array(output.slice(1, end));\r\n }\r\n}\r\nBufferUtils.BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\r\nBufferUtils.BASE32_ALPHABET = {\r\n RFC4648: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',\r\n RFC4648_HEX: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',\r\n KRYPTON: '0123456789ABCDEFGHJKLMNPQRSTUVXY'\r\n};\r\nBufferUtils.HEX_ALPHABET = '0123456789abcdef';\r\nBufferUtils._BASE64_LOOKUP = [];\r\nfor (let i = 0, len = BufferUtils.BASE64_ALPHABET.length; i < len; ++i) {\r\n BufferUtils._BASE64_LOOKUP[i] = BufferUtils.BASE64_ALPHABET[i];\r\n}\r\nBufferUtils.BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\r\n\r\nClass.register(BufferUtils);\r\n","class SerialBuffer extends Uint8Array {\r\n /**\r\n * @param {*} bufferOrArrayOrLength\r\n */\r\n constructor(bufferOrArrayOrLength) {\r\n super(bufferOrArrayOrLength);\r\n this._view = new DataView(this.buffer);\r\n this._readPos = 0;\r\n this._writePos = 0;\r\n }\r\n\r\n /**\r\n * @param {number} [start]\r\n * @param {number} [end]\r\n * @return {Uint8Array}\r\n */\r\n subarray(start, end) {\r\n return ArrayUtils.subarray(this, start, end);\r\n }\r\n\r\n /** @type {number} */\r\n get readPos() {\r\n return this._readPos;\r\n }\r\n\r\n /** @type {number} */\r\n set readPos(value) {\r\n if (value < 0 || value > this.byteLength) throw `Invalid readPos ${value}`;\r\n this._readPos = value;\r\n }\r\n\r\n /** @type {number} */\r\n get writePos() {\r\n return this._writePos;\r\n }\r\n\r\n /** @type {number} */\r\n set writePos(value) {\r\n if (value < 0 || value > this.byteLength) throw `Invalid writePos ${value}`;\r\n this._writePos = value;\r\n }\r\n\r\n /**\r\n * Resets the read and write position of the buffer to zero.\r\n * @returns {void}\r\n */\r\n reset() {\r\n this._readPos = 0;\r\n this._writePos = 0;\r\n }\r\n\r\n /**\r\n * @param {number} length\r\n * @return {Uint8Array}\r\n */\r\n read(length) {\r\n const value = this.subarray(this._readPos, this._readPos + length);\r\n this._readPos += length;\r\n return new Uint8Array(value);\r\n }\r\n\r\n /**\r\n * @param {*} array\r\n */\r\n write(array) {\r\n this.set(array, this._writePos);\r\n this._writePos += array.byteLength;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readUint8() {\r\n return this._view.getUint8(this._readPos++);\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeUint8(value) {\r\n this._view.setUint8(this._writePos++, value);\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readUint16() {\r\n const value = this._view.getUint16(this._readPos);\r\n this._readPos += 2;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeUint16(value) {\r\n this._view.setUint16(this._writePos, value);\r\n this._writePos += 2;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readUint32() {\r\n const value = this._view.getUint32(this._readPos);\r\n this._readPos += 4;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeUint32(value) {\r\n this._view.setUint32(this._writePos, value);\r\n this._writePos += 4;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readUint64() {\r\n const value = this._view.getUint32(this._readPos) * Math.pow(2, 32) + this._view.getUint32(this._readPos + 4);\r\n if (!NumberUtils.isUint64(value)) throw new Error('Malformed value');\r\n this._readPos += 8;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeUint64(value) {\r\n if (!NumberUtils.isUint64(value)) throw new Error('Malformed value');\r\n this._view.setUint32(this._writePos, Math.floor(value / Math.pow(2, 32)));\r\n this._view.setUint32(this._writePos + 4, value);\r\n this._writePos += 8;\r\n }\r\n\r\n /**\r\n * @return {BigNumber}\r\n */\r\n readUint128() {\r\n const op96 = new BigNumber('1000000000000000000000000', 16);\r\n const op64 = new BigNumber('10000000000000000', 16);\r\n const op32 = new BigNumber('100000000', 16);\r\n const part1 = this._view.getUint32(this._readPos);\r\n const part2 = this._view.getUint32(this._readPos + 4);\r\n const part3 = this._view.getUint32(this._readPos + 8);\r\n const part4 = this._view.getUint32(this._readPos + 12);\r\n const value = op96.times(part1).plus(op64.times(part2)).plus(op32.times(part3)).plus(part4);\r\n if (!NumberUtils.isUint128(value)) throw new Error('Malformed value');\r\n this._readPos += 16;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {BigNumber} value\r\n */\r\n writeUint128(value) {\r\n if (!NumberUtils.isUint128(value)) throw new Error('Malformed value');\r\n const op96 = new BigNumber('1000000000000000000000000', 16);\r\n const op64 = new BigNumber('10000000000000000', 16);\r\n const op32 = new BigNumber('100000000', 16);\r\n const part1 = value.idiv(op96);\r\n const part2 = value.mod(op96).idiv(op64);\r\n const part3 = value.mod(op64).idiv(op32);\r\n const part4 = value.mod(op32);\r\n this._view.setUint32(this._writePos, part1.toNumber());\r\n this._view.setUint32(this._writePos + 4, part2.toNumber());\r\n this._view.setUint32(this._writePos + 8, part3.toNumber());\r\n this._view.setUint32(this._writePos + 12, part4.toNumber());\r\n this._writePos += 16;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readVarUint() {\r\n const value = this.readUint8();\r\n if (value < 0xFD) {\r\n return value;\r\n } else if (value === 0xFD) {\r\n return this.readUint16();\r\n } else if (value === 0xFE) {\r\n return this.readUint32();\r\n } else /*if (value === 0xFF)*/ {\r\n return this.readUint64();\r\n }\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeVarUint(value) {\r\n if (!NumberUtils.isUint64(value)) throw new Error('Malformed value');\r\n if (value < 0xFD) {\r\n this.writeUint8(value);\r\n } else if (value <= 0xFFFF) {\r\n this.writeUint8(0xFD);\r\n this.writeUint16(value);\r\n } else if (value <= 0xFFFFFFFF) {\r\n this.writeUint8(0xFE);\r\n this.writeUint32(value);\r\n } else {\r\n this.writeUint8(0xFF);\r\n this.writeUint64(value);\r\n }\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n * @returns {number}\r\n */\r\n static varUintSize(value) {\r\n if (!NumberUtils.isUint64(value)) throw new Error('Malformed value');\r\n if (value < 0xFD) {\r\n return 1;\r\n } else if (value <= 0xFFFF) {\r\n return 3;\r\n } else if (value <= 0xFFFFFFFF) {\r\n return 5;\r\n } else {\r\n return 9;\r\n }\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n readFloat64() {\r\n const value = this._view.getFloat64(this._readPos);\r\n this._readPos += 8;\r\n return value;\r\n }\r\n\r\n /**\r\n * @param {number} value\r\n */\r\n writeFloat64(value) {\r\n this._view.setFloat64(this._writePos, value);\r\n this._writePos += 8;\r\n }\r\n\r\n /**\r\n * @param {number} length\r\n * @return {string}\r\n */\r\n readString(length) {\r\n const bytes = this.read(length);\r\n return BufferUtils.toAscii(bytes);\r\n }\r\n\r\n /**\r\n * @param {string} value\r\n * @param {number} length\r\n */\r\n writeString(value, length) {\r\n if (StringUtils.isMultibyte(value) || value.length !== length) throw new Error('Malformed value/length');\r\n const bytes = BufferUtils.fromAscii(value);\r\n this.write(bytes);\r\n }\r\n\r\n /**\r\n * @param {number} length\r\n * @return {string}\r\n */\r\n readPaddedString(length) {\r\n const bytes = this.read(length);\r\n let i = 0;\r\n while (i < length && bytes[i] !== 0x0) i++;\r\n const view = new Uint8Array(bytes.buffer, bytes.byteOffset, i);\r\n return BufferUtils.toAscii(view);\r\n }\r\n\r\n /**\r\n * @param {string} value\r\n * @param {number} length\r\n */\r\n writePaddedString(value, length) {\r\n if (StringUtils.isMultibyte(value) || value.length > length) throw new Error('Malformed value/length');\r\n const bytes = BufferUtils.fromAscii(value);\r\n this.write(bytes);\r\n const padding = length - bytes.byteLength;\r\n this.write(new Uint8Array(padding));\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n readVarLengthString() {\r\n const length = this.readUint8();\r\n if (this._readPos + length > this.length) throw new Error('Malformed length');\r\n const bytes = this.read(length);\r\n return BufferUtils.toAscii(bytes);\r\n }\r\n\r\n /**\r\n * @param {string} value\r\n */\r\n writeVarLengthString(value) {\r\n if (StringUtils.isMultibyte(value) || !NumberUtils.isUint8(value.length)) throw new Error('Malformed value');\r\n const bytes = BufferUtils.fromAscii(value);\r\n this.writeUint8(bytes.byteLength);\r\n this.write(bytes);\r\n }\r\n\r\n /**\r\n * @param {string} value\r\n * @returns {number}\r\n */\r\n static varLengthStringSize(value) {\r\n if (StringUtils.isMultibyte(value) || !NumberUtils.isUint8(value.length)) throw new Error('Malformed value');\r\n return /*length*/ 1 + value.length;\r\n }\r\n\r\n /**\r\n * @param {[SerialBuffer]} sources\r\n * @returns {SerialBuffer}\r\n */\r\n static concat(sources) {\r\n const length = sources.reduce((acc, arr) => acc + arr.length, 0);\r\n const result = new SerialBuffer(length);\r\n if (!sources.length) return result;\r\n \r\n let offset = 0;\r\n for(let arr of sources) {\r\n result.set(arr, offset);\r\n offset += arr.length;\r\n }\r\n\r\n return result;\r\n }\r\n}\r\nSerialBuffer.EMPTY = new SerialBuffer(0);\r\nClass.register(SerialBuffer);\r\n","/**\r\n * @interface\r\n * @deprecated\r\n */\r\nclass MinerWorker {\r\n /**\r\n * @param blockHeader\r\n * @param compact\r\n * @param minNonce\r\n * @param maxNonce\r\n * @returns {Promise.<{hash: Uint8Array, nonce: number}|boolean>}\r\n */\r\n async multiMine(blockHeader, compact, minNonce, maxNonce) {}\r\n}\r\nClass.register(MinerWorker);\r\n","/**\r\n * @deprecated\r\n */\r\nclass MinerWorkerImpl extends IWorker.Stub(MinerWorker) {\r\n constructor() {\r\n super();\r\n // FIXME: This is needed for Babel to work correctly. Can be removed as soon as we updated to Babel v7.\r\n this._superInit = super.init;\r\n }\r\n\r\n async init(name) {\r\n await this._superInit.call(this, name);\r\n if (PlatformUtils.isBrowser()) await WasmHelper.doImportBrowser();\r\n }\r\n\r\n async multiMine(input, compact, minNonce, maxNonce) {\r\n const hash = new Uint8Array(32);\r\n let wasmOut, wasmIn;\r\n try {\r\n wasmOut = Module._malloc(hash.length);\r\n wasmIn = Module._malloc(input.length);\r\n Module.HEAPU8.set(input, wasmIn);\r\n const nonce = Module._krypton_argon2_target(wasmOut, wasmIn, input.length, compact, minNonce, maxNonce, 512);\r\n if (nonce === maxNonce) return false;\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hash.length));\r\n return {hash, nonce};\r\n } catch (e) {\r\n Log.w(MinerWorkerImpl, e);\r\n throw e;\r\n } finally {\r\n if (wasmOut !== undefined) Module._free(wasmOut);\r\n if (wasmIn !== undefined) Module._free(wasmIn);\r\n }\r\n }\r\n}\r\n\r\nIWorker.prepareForWorkerUse(MinerWorker, new MinerWorkerImpl());\r\n","/**\r\n * @deprecated\r\n */\r\nclass MinerWorkerPool extends IWorker.Pool(MinerWorker) {\r\n constructor(size = 1) {\r\n super((name) => IWorker.startWorkerForProxy(MinerWorker, name), 'miner', size);\r\n /** @type {boolean} */\r\n this._miningEnabled = false;\r\n /** @type {Array.<{minNonce: number, maxNonce: number}>} */\r\n this._activeNonces = [];\r\n /** @type {Block} */\r\n this._block = null;\r\n /** @type {number} */\r\n this._noncesPerRun = 256;\r\n /** @type {Observable} */\r\n this._observable = new Observable();\r\n /** @type {number} */\r\n this._shareCompact = Policy.BLOCK_TARGET_MAX;\r\n /** @type {number} */\r\n this._runsPerCycle = Infinity;\r\n /** @type {number} */\r\n this._cycleWait = 100;\r\n\r\n // FIXME: This is needed for Babel to work correctly. Can be removed as soon as we updated to Babel v7.\r\n this._superUpdateToSize = super._updateToSize;\r\n\r\n if (PlatformUtils.isNodeJs()) {\r\n Log.i(MinerWorkerPool, `Using add-on optimized for instruction set: ${cpuSupport}`);\r\n\r\n /**\r\n * @param {SerialBuffer} blockHeader\r\n * @param {number} compact\r\n * @param {number} minNonce\r\n * @param {number} maxNonce\r\n * @returns {Promise.<{hash: Uint8Array, nonce: number}|boolean>}\r\n */\r\n this.multiMine = function (blockHeader, compact, minNonce, maxNonce) {\r\n return new Promise((resolve, fail) => {\r\n NodeNative.node_argon2_target_async(async (nonce) => {\r\n try {\r\n if (nonce === maxNonce) {\r\n resolve(false);\r\n } else {\r\n blockHeader.writePos -= 4;\r\n blockHeader.writeUint32(nonce);\r\n const hash = await (await CryptoWorker.getInstanceAsync()).computeArgon2d(blockHeader);\r\n resolve({hash, nonce});\r\n }\r\n } catch (e) {\r\n fail(e);\r\n }\r\n }, blockHeader, compact, minNonce, maxNonce, 512);\r\n });\r\n };\r\n }\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get noncesPerRun() {\r\n return this._noncesPerRun;\r\n }\r\n\r\n /**\r\n * @param {number} nonces\r\n */\r\n set noncesPerRun(nonces) {\r\n this._noncesPerRun = nonces;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get runsPerCycle() {\r\n return this._runsPerCycle;\r\n }\r\n\r\n /**\r\n * @param {number} runsPerCycle\r\n */\r\n set runsPerCycle(runsPerCycle) {\r\n this._runsPerCycle = runsPerCycle;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get cycleWait() {\r\n return this._cycleWait;\r\n }\r\n\r\n /**\r\n * @param {number} cycleWait\r\n */\r\n set cycleWait(cycleWait) {\r\n this._cycleWait = cycleWait;\r\n }\r\n\r\n /**\r\n * @param {string} type\r\n * @param {Function} callback\r\n * @return {number}\r\n */\r\n on(type, callback) { return this._observable.on(type, callback); }\r\n\r\n /**\r\n * @param {string} type\r\n * @param {number} id\r\n */\r\n off(type, id) { this._observable.off(type, id); }\r\n\r\n /**\r\n * @param {Block} block\r\n * @param {number} [shareCompact] target of a share, in compact format.\r\n */\r\n async startMiningOnBlock(block, shareCompact) {\r\n this._block = block;\r\n this._shareCompact = shareCompact || block.nBits;\r\n if (!this._miningEnabled) {\r\n await this._updateToSize();\r\n this._activeNonces = [];\r\n this._miningEnabled = true;\r\n for (let i = 0; i < this.poolSize; ++i) {\r\n this._startMiner();\r\n }\r\n } else {\r\n this._activeNonces = [{minNonce:0, maxNonce:0}];\r\n }\r\n }\r\n\r\n stop() {\r\n this._miningEnabled = false;\r\n }\r\n\r\n async _updateToSize() {\r\n if (!PlatformUtils.isNodeJs()) {\r\n await this._superUpdateToSize.call(this);\r\n }\r\n\r\n while (this._miningEnabled && this._activeNonces.length < this.poolSize) {\r\n this._startMiner();\r\n }\r\n }\r\n\r\n _startMiner() {\r\n if (this._activeNonces.length >= this.poolSize) {\r\n return;\r\n }\r\n\r\n const minNonce = this._activeNonces.length === 0 ? 0 : Math.max.apply(null, this._activeNonces.map((a) => a.maxNonce));\r\n const maxNonce = minNonce + this._noncesPerRun;\r\n const nonceRange = {minNonce, maxNonce};\r\n this._activeNonces.push(nonceRange);\r\n this._singleMiner(nonceRange).catch((e) => Log.e(MinerWorkerPool, e));\r\n }\r\n\r\n /**\r\n * @param {{minNonce: number, maxNonce: number}} nonceRange\r\n * @return {Promise.<void>}\r\n * @private\r\n */\r\n async _singleMiner(nonceRange) {\r\n let i = 0;\r\n while (this._miningEnabled && (IWorker.areWorkersAsync || PlatformUtils.isNodeJs() || i === 0) && i < this._runsPerCycle) {\r\n i++;\r\n const block = this._block;\r\n const result = await this.multiMine(block.header.serialize(), this._shareCompact, nonceRange.minNonce, nonceRange.maxNonce);\r\n if (result) {\r\n const hash = new Hash(result.hash);\r\n this._observable.fire('share', {\r\n block,\r\n nonce: result.nonce,\r\n hash\r\n });\r\n } else {\r\n this._observable.fire('no-share', {\r\n nonce: nonceRange.maxNonce\r\n });\r\n }\r\n if (this._activeNonces.length > this.poolSize) {\r\n this._activeNonces.splice(this._activeNonces.indexOf(nonceRange), 1);\r\n return;\r\n } else {\r\n const newMin = Math.max.apply(null, this._activeNonces.map((a) => a.maxNonce));\r\n const newRange = {minNonce: newMin, maxNonce: newMin + this._noncesPerRun};\r\n this._activeNonces.splice(this._activeNonces.indexOf(nonceRange), 1, newRange);\r\n nonceRange = newRange;\r\n }\r\n }\r\n if (this._miningEnabled) {\r\n setTimeout(() => this._singleMiner(nonceRange), this._cycleWait);\r\n }\r\n }\r\n}\r\n\r\nClass.register(MinerWorkerPool);\r\n","class PlatformUtils {\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isBrowser() {\r\n return true;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isWeb() {\r\n return typeof window !== 'undefined';\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isNodeJs() {\r\n return false;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static supportsWebRTC() {\r\n const RTCPeerConnection = PlatformUtils.isBrowser() ? (window.RTCPeerConnection || window.webkitRTCPeerConnection) : null;\r\n return !!RTCPeerConnection && typeof RTCPeerConnection.prototype.createDataChannel === 'function';\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static supportsWS() {\r\n return location && location.protocol === 'http:';\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isOnline() {\r\n return !('onLine' in window.navigator) || window.navigator.onLine;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n static isWindows() {\r\n return /^win/.test(window.navigator.platform);\r\n }\r\n\r\n static get userAgentString() {\r\n try {\r\n return window.navigator.platform;\r\n } catch (e) {\r\n return 'unknown';\r\n }\r\n }\r\n\r\n static get hardwareConcurrency() {\r\n if (typeof navigator === 'object' && navigator.hardwareConcurrency) {\r\n return navigator.hardwareConcurrency;\r\n } else {\r\n return 1;\r\n }\r\n }\r\n}\r\n\r\nClass.register(PlatformUtils);\r\n","class WasmHelper {\r\n\r\n static async doImport() {\r\n return WasmHelper.doImportBrowser();\r\n }\r\n\r\n static async doImportBrowser() {\r\n WasmHelper._importBrowserPromise = WasmHelper._importBrowserPromise || (async () => {\r\n if (await WasmHelper.importWasmBrowser('worker-wasm.wasm')) {\r\n await WasmHelper.importScriptBrowser('worker-wasm.js', 'Module', '{WORKER_WASM_HASH}');\r\n } else {\r\n await WasmHelper.importScriptBrowser('worker-js.js', 'Module', '{WORKER_JS_HASH}');\r\n }\r\n })();\r\n try {\r\n await WasmHelper._importBrowserPromise;\r\n } catch (e) {\r\n WasmHelper._importBrowserPromise = null;\r\n throw e;\r\n }\r\n }\r\n\r\n /**\r\n * @param {string} wasm\r\n * @param {string} module\r\n * @returns {Promise.<boolean>}\r\n */\r\n static async importWasm(wasm, module = 'Module') {\r\n return WasmHelper.importWasmBrowser(wasm, module);\r\n }\r\n\r\n /**\r\n * @param {string} wasm\r\n * @param {string} module\r\n * @returns {Promise.<boolean>}\r\n */\r\n static async importWasmBrowser(wasm, module = 'Module') {\r\n wasm = WasmHelper._adjustWasmPath(wasm);\r\n if (!WasmHelper._global.WebAssembly) {\r\n Log.w(WasmHelper, 'No support for WebAssembly available.');\r\n return Promise.resolve(false);\r\n }\r\n\r\n return new Promise((resolve) => {\r\n try {\r\n const xhr = new XMLHttpRequest();\r\n xhr.open('GET', wasm, true);\r\n xhr.responseType = 'arraybuffer';\r\n xhr.onload = function () {\r\n WasmHelper._global[module] = WasmHelper._global[module] || {};\r\n WasmHelper._global[module].wasmBinary = xhr.response;\r\n resolve(true);\r\n };\r\n xhr.onerror = function () {\r\n Log.w(WasmHelper, `Failed to access WebAssembly module ${wasm}`);\r\n resolve(false);\r\n };\r\n xhr.send(null);\r\n } catch (e) {\r\n Log.w(WasmHelper, `Failed to access WebAssembly module ${wasm}`);\r\n resolve(false);\r\n }\r\n });\r\n }\r\n\r\n static async importScript(script, module = 'Module') {\r\n return WasmHelper.importScriptBrowser(script, module);\r\n }\r\n\r\n static async importScriptBrowser(script, module = 'Module', integrity=null) {\r\n if (module && WasmHelper._global[module] && WasmHelper._global[module].asm) return false;\r\n script = WasmHelper._adjustScriptPath(script);\r\n\r\n const moduleSettings = WasmHelper._global[module] || {};\r\n return new Promise(async (resolve, reject) => {\r\n const runtimeInitialized = new Promise((resolve) => {\r\n moduleSettings.onRuntimeInitialized = () => resolve(true);\r\n });\r\n if (typeof importScripts === 'function') {\r\n await new Promise((resolve) => {\r\n WasmHelper._moduleLoadedCallbacks[module] = resolve;\r\n importScripts(script);\r\n });\r\n WasmHelper._global[module] = WasmHelper._global[module](moduleSettings);\r\n } else if (typeof window === 'object') {\r\n await new Promise((resolve) => {\r\n WasmHelper._moduleLoadedCallbacks[module] = resolve;\r\n WasmHelper._loadBrowserScript(script, integrity);\r\n });\r\n WasmHelper._global[module] = WasmHelper._global[module](moduleSettings);\r\n } else if (typeof require === 'function') {\r\n WasmHelper._global[module] = require(script)(moduleSettings);\r\n } else {\r\n reject('No way to load scripts.');\r\n return;\r\n }\r\n await runtimeInitialized;\r\n if (moduleSettings.asm && !WasmHelper._global[module].asm) WasmHelper._global[module] = moduleSettings;\r\n resolve(true);\r\n });\r\n }\r\n\r\n static fireModuleLoaded(module = 'Module') {\r\n if (typeof WasmHelper._moduleLoadedCallbacks[module] === 'function') {\r\n WasmHelper._moduleLoadedCallbacks[module]();\r\n WasmHelper._moduleLoadedCallbacks[module] = null;\r\n }\r\n }\r\n\r\n static _loadBrowserScript(url, integrity) {\r\n const head = document.getElementsByTagName('head')[0];\r\n const script = document.createElement('script');\r\n script.type = 'text/javascript';\r\n script.src = url;\r\n if (integrity != null) {\r\n script.integrity = integrity;\r\n script.crossOrigin = 'anonymous';\r\n }\r\n head.appendChild(script);\r\n }\r\n\r\n static _adjustWasmPath(wasm) {\r\n if (typeof Krypton !== 'undefined' && Krypton._path) wasm = `${Krypton._path}${wasm}`;\r\n if (typeof __dirname === 'string' && wasm.indexOf('/') === -1) wasm = `${__dirname}/${wasm}`;\r\n return wasm;\r\n }\r\n\r\n static _adjustScriptPath(script) {\r\n if (typeof Krypton !== 'undefined' && Krypton._path) script = `${Krypton._path}${script}`;\r\n if (typeof __dirname === 'string' && script.indexOf('/') === -1) script = `${__dirname}/${script}`;\r\n return script;\r\n }\r\n\r\n static get _global() {\r\n return typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : null;\r\n }\r\n}\r\n\r\nWasmHelper._moduleLoadedCallbacks = {};\r\n\r\nClass.register(WasmHelper);\r\n","class GenesisConfig {}\r\nClass.register(GenesisConfig);\r\n","class ArrayUtils {\r\n /**\r\n * @template T\r\n * @param {Array.<T>} arr\r\n * @return {T}\r\n */\r\n static randomElement(arr) {\r\n return arr[Math.floor(Math.random() * arr.length)];\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} uintarr\r\n * @param {number} [begin]\r\n * @param {number} [end]\r\n * @return {Uint8Array}\r\n */\r\n static subarray(uintarr, begin, end) {\r\n function clamp(v, min, max) { return v < min ? min : v > max ? max : v; }\r\n\r\n if (begin === undefined) { begin = 0; }\r\n if (end === undefined) { end = uintarr.byteLength; }\r\n\r\n begin = clamp(begin, 0, uintarr.byteLength);\r\n end = clamp(end, 0, uintarr.byteLength);\r\n\r\n let len = end - begin;\r\n if (len < 0) {\r\n len = 0;\r\n }\r\n\r\n return new Uint8Array(uintarr.buffer, uintarr.byteOffset + begin, len);\r\n }\r\n\r\n /**\r\n * @param {Array} list\r\n * @param {number} k\r\n * @yields {Array}\r\n */\r\n static *k_combinations(list, k) {\r\n const n = list.length;\r\n // Shortcut:\r\n if (k > n) {\r\n return;\r\n }\r\n const indices = Array.from(new Array(k), (x,i) => i);\r\n yield indices.map(i => list[i]);\r\n const reverseRange = Array.from(new Array(k), (x,i) => k-i-1);\r\n /*eslint no-constant-condition: [\"error\", { \"checkLoops\": false }]*/\r\n while (true) {\r\n let i = k-1, found = false;\r\n for (i of reverseRange) {\r\n if (indices[i] !== i + n - k) {\r\n found = true;\r\n break;\r\n }\r\n }\r\n if (!found) {\r\n return;\r\n }\r\n indices[i] += 1;\r\n for (const j of Array.from(new Array(k-i-1), (x,k) => i+k+1)) {\r\n indices[j] = indices[j-1] + 1;\r\n }\r\n yield indices.map(i => list[i]);\r\n }\r\n }\r\n}\r\nClass.register(ArrayUtils);\r\n","class Assert {\r\n /**\r\n * @param {boolean} condition\r\n * @param {string} [message]\r\n * @returns {void}\r\n */\r\n static that(condition, message = 'Assertion failed') {\r\n if (!condition) {\r\n throw new Error(message);\r\n }\r\n }\r\n}\r\nClass.register(Assert);\r\n","class MerkleTree {\r\n /**\r\n * @param {Array} values\r\n * @param {function(o: *):Hash} [fnHash]\r\n * @returns {Hash}\r\n */\r\n static computeRoot(values, fnHash = MerkleTree._hash) {\r\n return MerkleTree._computeRoot(values, fnHash);\r\n }\r\n\r\n /**\r\n * @param {Array} values\r\n * @param {function(o: *):Hash} fnHash\r\n * @returns {Hash}\r\n * @private\r\n */\r\n static _computeRoot(values, fnHash) {\r\n const len = values.length;\r\n if (len === 0) {\r\n return Hash.light(new Uint8Array(0));\r\n }\r\n if (len === 1) {\r\n return fnHash(values[0]);\r\n }\r\n\r\n const mid = Math.round(len / 2);\r\n const left = values.slice(0, mid);\r\n const right = values.slice(mid);\r\n const leftHash = MerkleTree._computeRoot(left, fnHash);\r\n const rightHash = MerkleTree._computeRoot(right, fnHash);\r\n return Hash.light(BufferUtils.concatTypedArrays(leftHash.serialize(), rightHash.serialize()));\r\n }\r\n\r\n /**\r\n * @param {Hash|Uint8Array|{hash: function():Hash}|{serialize: function():Uint8Array}} o\r\n * @returns {Hash}\r\n * @private\r\n */\r\n static _hash(o) {\r\n if (o instanceof Hash) {\r\n return o;\r\n }\r\n if (typeof o.hash === 'function') {\r\n return o.hash();\r\n }\r\n if (typeof o.serialize === 'function') {\r\n return Hash.light(o.serialize());\r\n }\r\n if (o instanceof Uint8Array) {\r\n return Hash.light(o);\r\n }\r\n throw new Error('MerkleTree objects must be Uint8Array or have a .hash()/.serialize() method');\r\n }\r\n}\r\nClass.register(MerkleTree);\r\n","class MerklePath {\r\n /**\r\n * @param {Array.<MerklePathNode>} nodes\r\n */\r\n constructor(nodes) {\r\n if (!Array.isArray(nodes) || !NumberUtils.isUint8(nodes.length)\r\n || nodes.some(it => !(it instanceof MerklePathNode))) throw new Error('Malformed nodes');\r\n /**\r\n * @type {Array.<MerklePathNode>}\r\n * @private\r\n */\r\n this._nodes = nodes;\r\n }\r\n\r\n /**\r\n * @param {Array} values\r\n * @param {*} leafValue\r\n * @param {function(o: *):Hash} [fnHash]\r\n * @returns {MerklePath}\r\n */\r\n static compute(values, leafValue, fnHash = MerkleTree._hash) {\r\n const leafHash = fnHash(leafValue);\r\n const path = [];\r\n MerklePath._compute(values, leafHash, path, fnHash);\r\n return new MerklePath(path);\r\n }\r\n\r\n /**\r\n * @param {Array} values\r\n * @param {Hash} leafHash\r\n * @param {Array.<MerklePathNode>} path\r\n * @param {function(o: *):Hash} fnHash\r\n * @returns {{containsLeaf:boolean, inner:Hash}}\r\n * @private\r\n */\r\n static _compute(values, leafHash, path, fnHash) {\r\n const len = values.length;\r\n let hash;\r\n if (len === 0) {\r\n hash = Hash.light(new Uint8Array(0));\r\n return {containsLeaf: false, inner: hash};\r\n }\r\n if (len === 1) {\r\n hash = fnHash(values[0]);\r\n return {containsLeaf: hash.equals(leafHash), inner: hash};\r\n }\r\n\r\n const mid = Math.round(len / 2);\r\n const left = values.slice(0, mid);\r\n const right = values.slice(mid);\r\n const {containsLeaf: leftLeaf, inner: leftHash} = MerklePath._compute(left, leafHash, path, fnHash);\r\n const {containsLeaf: rightLeaf, inner: rightHash} = MerklePath._compute(right, leafHash, path, fnHash);\r\n hash = Hash.light(BufferUtils.concatTypedArrays(leftHash.serialize(), rightHash.serialize()));\r\n\r\n if (leftLeaf) {\r\n path.push(new MerklePathNode(rightHash, false));\r\n return {containsLeaf: true, inner: hash};\r\n } else if (rightLeaf) {\r\n path.push(new MerklePathNode(leftHash, true));\r\n return {containsLeaf: true, inner: hash};\r\n }\r\n\r\n return {containsLeaf: false, inner: hash};\r\n }\r\n\r\n /**\r\n * @param {*} leafValue\r\n * @param {function(o: *):Hash} [fnHash]\r\n * @returns {Hash}\r\n */\r\n computeRoot(leafValue, fnHash = MerkleTree._hash) {\r\n /** @type {Hash} */\r\n let root = fnHash(leafValue);\r\n for (const node of this._nodes) {\r\n const left = node.left;\r\n const hash = node.hash;\r\n const concat = new SerialBuffer(hash.serializedSize * 2);\r\n if (left) hash.serialize(concat);\r\n root.serialize(concat);\r\n if (!left) hash.serialize(concat);\r\n root = Hash.light(concat);\r\n }\r\n return root;\r\n }\r\n\r\n /**\r\n * @param {Array.<MerklePathNode>} nodes\r\n * @returns {Uint8Array}\r\n * @private\r\n */\r\n static _compress(nodes) {\r\n const count = nodes.length;\r\n const leftBitsSize = Math.ceil(count / 8);\r\n const leftBits = new Uint8Array(leftBitsSize);\r\n\r\n for (let i = 0; i < count; i++) {\r\n if (nodes[i].left) {\r\n leftBits[Math.floor(i / 8)] |= 0x80 >>> (i % 8);\r\n }\r\n }\r\n\r\n return leftBits;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @returns {MerklePath}\r\n */\r\n static unserialize(buf) {\r\n const count = buf.readUint8();\r\n const leftBitsSize = Math.ceil(count / 8);\r\n const leftBits = buf.read(leftBitsSize);\r\n\r\n const nodes = [];\r\n for (let i = 0; i < count; i++) {\r\n const left = (leftBits[Math.floor(i / 8)] & (0x80 >>> (i % 8))) !== 0;\r\n const algorithm = buf.readUint8();\r\n const hash = Hash.unserialize(buf, algorithm);\r\n nodes.push(new MerklePathNode(hash, left));\r\n }\r\n return new MerklePath(nodes);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(this._nodes.length);\r\n buf.write(MerklePath._compress(this._nodes));\r\n\r\n for (const node of this._nodes) {\r\n buf.writeUint8(node.hash.algorithm);\r\n node.hash.serialize(buf);\r\n }\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n const leftBitsSize = Math.ceil(this._nodes.length / 8);\r\n return /*count*/ 1\r\n + leftBitsSize\r\n + this._nodes.reduce((sum, node) => sum + /*algorithm*/ 1 + node.hash.serializedSize, 0);\r\n }\r\n\r\n /**\r\n * @param {MerklePath} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof MerklePath\r\n && this._nodes.length === o._nodes.length\r\n && this._nodes.every((node, i) => node.equals(o._nodes[i]));\r\n }\r\n\r\n /** @type {Array.<MerklePathNode>} */\r\n get nodes() {\r\n return this._nodes;\r\n }\r\n}\r\nClass.register(MerklePath);\r\n\r\nclass MerklePathNode {\r\n /**\r\n * @param {Hash} hash\r\n * @param {boolean} left\r\n */\r\n constructor(hash, left) {\r\n this._hash = hash;\r\n this._left = left;\r\n }\r\n\r\n /** @type {Hash} */\r\n get hash() {\r\n return this._hash;\r\n }\r\n\r\n /** @type {boolean} */\r\n get left() {\r\n return this._left;\r\n }\r\n\r\n /**\r\n * @param {MerklePathNode} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof MerklePathNode\r\n && this._hash.equals(o.hash)\r\n && this._left === o.left;\r\n }\r\n}\r\nClass.register(MerklePathNode);\r\n","class Policy {\r\n /**\r\n * Convert Krypton decimal to Number of Satoshis.\r\n * @param {BigNumber|number|string} coins Krypton count in decimal\r\n * @return {BigNumber} Number of Satoshis\r\n */\r\n static coinsToSatoshis(coins) {\r\n return new BigNumber(coins).times(Policy.SATOSHIS_PER_COIN).integerValue();\r\n }\r\n\r\n /**\r\n * Convert Number of Satoshis to Krypton decimal.\r\n * @param {BigNumber|number|string} satoshis Number of Satoshis.\r\n * @return {BigNumber} Krypton count in decimal.\r\n */\r\n static satoshisToCoins(satoshis) {\r\n return new BigNumber(satoshis).div(Policy.SATOSHIS_PER_COIN);\r\n }\r\n\r\n /**\r\n * Miner reward per block.\r\n * @param {number} blockHeight\r\n * @return {BigNumber}\r\n */\r\n static blockRewardAt(blockHeight) {\r\n if (blockHeight <= 0) return new BigNumber(0);\r\n const halving = Math.min(Math.floor((blockHeight - 1) / Policy.HALVING_INTERVAL), Policy.HALVING_TARGET_MAX - 1);\r\n return new BigNumber(Policy.INITIAL_BLOCK_REWARD).idiv(Math.pow(2, halving));\r\n }\r\n\r\n /**\r\n * targeted block time of block.\r\n * @param {number} blockHeight\r\n * @return {number}\r\n */\r\n static blockTime(blockHeight) {\r\n if (blockHeight <= Policy.BLOCK_TIME_MILESTONE) return Policy.INITIAL_BLOCK_TIME;\r\n if (blockHeight > Policy.HALVING_INTERVAL * Policy.HALVING_TARGET_MAX) return Policy.INITIAL_BLOCK_TIME;\r\n\r\n return Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - Math.floor((blockHeight - 1) / Policy.HALVING_INTERVAL));\r\n }\r\n\r\n /**\r\n * targeted time for block height.\r\n * @param {number} blockHeight\r\n * @return {number}\r\n */\r\n static targetedTime(blockHeight) {\r\n if (blockHeight <= Policy.BLOCK_TIME_MILESTONE) return (blockHeight - 1) * Policy.INITIAL_BLOCK_TIME;\r\n\r\n const initial = Policy.BLOCK_TIME_MILESTONE * Policy.INITIAL_BLOCK_TIME;\r\n const secondBlockTime = Policy.BLOCK_TIME_MULTIPLE * Policy.HALVING_TARGET_MAX;\r\n if (blockHeight <= Policy.HALVING_INTERVAL) {\r\n return initial + (blockHeight - Policy.BLOCK_TIME_MILESTONE - 1) * secondBlockTime;\r\n }\r\n\r\n // first range\r\n let target = initial + (Policy.HALVING_INTERVAL - Policy.BLOCK_TIME_MILESTONE) * secondBlockTime;\r\n // from second range\r\n let height = blockHeight - Policy.HALVING_INTERVAL;\r\n let count = 1;\r\n // calculate for each range\r\n while (height > Policy.HALVING_INTERVAL && count < Policy.HALVING_TARGET_MAX) {\r\n target += Policy.HALVING_INTERVAL * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - count);\r\n height -= Policy.HALVING_INTERVAL;\r\n count += 1;\r\n }\r\n // last\r\n if (count >= Policy.HALVING_TARGET_MAX) {\r\n target += (height - 1) * Policy.INITIAL_BLOCK_TIME;\r\n } else {\r\n target += (height - 1) * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - count);\r\n }\r\n\r\n return target;\r\n }\r\n\r\n /**\r\n * targeted time of block range.\r\n * @param {number} begin\r\n * @param {number} end\r\n * @return {number}\r\n */\r\n static targetedTimeBlockRange(begin, end) {\r\n const beginBlock = begin > 1 ? begin : 1;\r\n const endBlock = end > 1 ? end : 1;\r\n if (beginBlock >= endBlock) return 0;\r\n\r\n const blockMilestoneMax = Policy.HALVING_INTERVAL * Policy.HALVING_TARGET_MAX;\r\n let range = endBlock - beginBlock;\r\n if (endBlock <= Policy.BLOCK_TIME_MILESTONE || beginBlock > blockMilestoneMax) {\r\n return range * Policy.INITIAL_BLOCK_TIME;\r\n }\r\n \r\n const secondBlockTime = Policy.BLOCK_TIME_MULTIPLE * Policy.HALVING_TARGET_MAX;\r\n if (endBlock <= Policy.HALVING_INTERVAL) {\r\n if (beginBlock <= Policy.BLOCK_TIME_MILESTONE) {\r\n return (Policy.BLOCK_TIME_MILESTONE - beginBlock + 1) * Policy.INITIAL_BLOCK_TIME + (endBlock - Policy.BLOCK_TIME_MILESTONE - 1) * secondBlockTime;\r\n }\r\n return range * secondBlockTime;\r\n }\r\n\r\n const beginRangeIndex = Math.floor((beginBlock - 1) / Policy.HALVING_INTERVAL);\r\n let endRangeIndex = Math.floor((endBlock - 1) / Policy.HALVING_INTERVAL);\r\n // in a range\r\n if (beginRangeIndex === endRangeIndex) {\r\n return range * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - beginRangeIndex);\r\n }\r\n\r\n let beginBlocksTime;\r\n let middleBlocksTime = 0;\r\n let endBlocksTime;\r\n if (beginBlock <= Policy.BLOCK_TIME_MILESTONE) {\r\n beginBlocksTime = (Policy.BLOCK_TIME_MILESTONE - beginBlock + 1) * Policy.INITIAL_BLOCK_TIME + (Policy.HALVING_INTERVAL - Policy.BLOCK_TIME_MILESTONE) * secondBlockTime;\r\n } else {\r\n const beginBlockMilestone = (beginRangeIndex + 1) * Policy.HALVING_INTERVAL;\r\n beginBlocksTime = (beginBlockMilestone - beginBlock + 1) * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - beginRangeIndex);\r\n }\r\n if (endBlock > blockMilestoneMax) {\r\n endRangeIndex = Policy.HALVING_TARGET_MAX;\r\n endBlocksTime = (endBlock - blockMilestoneMax - 1) * Policy.INITIAL_BLOCK_TIME;\r\n } else {\r\n const endBlockMilestone = endRangeIndex * Policy.HALVING_INTERVAL;\r\n endBlocksTime = (endBlock - endBlockMilestone - 1) * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - endRangeIndex);\r\n }\r\n for (let i = beginRangeIndex + 1; i < endRangeIndex; i++) {\r\n middleBlocksTime += Policy.HALVING_INTERVAL * Policy.BLOCK_TIME_MULTIPLE * (Policy.HALVING_TARGET_MAX - i);\r\n }\r\n return beginBlocksTime + middleBlocksTime + endBlocksTime;\r\n }\r\n\r\n /**\r\n * tx fee at block.\r\n * @param {number} blockHeight\r\n * @return {BigNumber}\r\n */\r\n static txFee(blockHeight) {\r\n if (blockHeight <= 1) return new BigNumber(0);\r\n const changing = Math.floor((blockHeight - 1) / Policy.TX_FEE_CHANGING_INTERVAL);\r\n if (changing < Policy.TX_FEE_CHANGING_TOTAL_NUMBER) {\r\n return new BigNumber(Policy.INITIAL_TX_FEE).div(Math.pow(10, changing));\r\n }\r\n return new BigNumber(1);\r\n }\r\n\r\n /**\r\n * block size.\r\n * @param {number} blockHeight\r\n * @return {number}\r\n */\r\n static blockSize(blockHeight) {\r\n if (blockHeight < Policy.FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE) return Policy.INITIAL_BLOCK_SIZE;\r\n return Policy.BASE_BLOCK_SIZE + Policy.BLOCK_SIZE_FACTOR * Math.floor(blockHeight / Policy.BLOCK_SIZE_CHANGING_INTERVAL);\r\n }\r\n\r\n /**\r\n * difficulty block window\r\n * @param {number} blockHeight\r\n * @return {number}\r\n */\r\n static difficultyBlockWindow(blockHeight) {\r\n if (blockHeight >= Policy.SECOND_FORKING_FOR_BLOCK_DIFFICULTY\r\n || blockHeight < Policy.FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE) return Policy.DIFFICULTY_BLOCK_WINDOW;\r\n \r\n const time = Policy.blockTime(blockHeight);\r\n return Math.floor(360 / time);\r\n }\r\n}\r\n\r\n/**\r\n * Targeted block time in seconds.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.INITIAL_BLOCK_TIME = 3;\r\n\r\n/**\r\n * Multiple block time argument.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BLOCK_TIME_MULTIPLE = 3;\r\n\r\n/**\r\n * Milestone for the first time that block time changed.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BLOCK_TIME_MILESTONE = 1100000;\r\n\r\n/**\r\n * Initial block size in bytes.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.INITIAL_BLOCK_SIZE = 1e5; // 100 kb\r\n\r\n/**\r\n * base block size in bytes.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BASE_BLOCK_SIZE = 2100000; // 2.1 Mb\r\n\r\n/**\r\n * block size factor in bytes.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BLOCK_SIZE_FACTOR = 2100; // 2.1 kb\r\n\r\n/**\r\n * Block size will be change every 2.1M blocks.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.BLOCK_SIZE_CHANGING_INTERVAL = 2100000;\r\n\r\n/**\r\n * The highest (easiest) block PoW target.\r\n * @type {BigNumber}\r\n * @constant\r\n */\r\nPolicy.BLOCK_TARGET_MAX = new BigNumber(2).pow(240);\r\n\r\n/**\r\n * Number of blocks we take into account to calculate next difficulty.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.DIFFICULTY_BLOCK_WINDOW = 120;\r\n\r\n/**\r\n * Block number that we apply some new settings about block difficulty, block size.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE = 1124816;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted min/max.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.DIFFICULTY_MAX_ADJUSTMENT_FACTOR = 2;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted max.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.NEW_DIFFICULTY_MAX_ADJUSTMENT_FACTOR = 1.3;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted min.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.NEW_DIFFICULTY_MIN_ADJUSTMENT_FACTOR = 0.7;\r\n\r\n/**\r\n * Block number that we apply some new settings about block difficulty (the second).\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.SECOND_FORKING_FOR_BLOCK_DIFFICULTY = 1132333;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted max (the second).\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.SECOND_DIFFICULTY_MAX_ADJUSTMENT_FACTOR = 1.5;\r\n\r\n/**\r\n * Limits the rate at which the difficulty is adjusted min (the second).\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.SECOND_DIFFICULTY_MIN_ADJUSTMENT_FACTOR = 0.5;\r\n\r\n/**\r\n * Number of blocks a transaction is valid.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.TRANSACTION_VALIDITY_WINDOW = 120;\r\n\r\n\r\n/* Supply & Emission Parameters */\r\n\r\n/**\r\n * Number of Satoshis per Krypton.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.SATOSHIS_PER_COIN = 1e11;\r\n\r\n/**\r\n * Initial supply before genesis block in satoshis.\r\n * @type {number}\r\n * @constant\r\n */\r\n\r\nPolicy.INITIAL_SUPPLY = 0;\r\n\r\n/**\r\n * block reward in satoshis\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.INITIAL_BLOCK_REWARD = 5e11;\r\n\r\n/**\r\n * in this time the block reward should not be halved anymore\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.HALVING_TARGET_MAX = 21;\r\n\r\n/**\r\n * halving the block reward each 2.100.000 blocks\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.HALVING_INTERVAL = 2100000;\r\n\r\n/* Security parameters */\r\n\r\n/**\r\n * NIPoPoW Security parameter M\r\n * FIXME naming\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.M = 240;\r\n\r\n/**\r\n * NIPoPoW Security parameter K\r\n * FIXME naming\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.K = 120;\r\n\r\n/**\r\n * NIPoPoW Security parameter DELTA\r\n * FIXME naming\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.DELTA = 0.15;\r\n\r\n/**\r\n * Number of blocks the light client downloads to verify the AccountsTree construction.\r\n * FIXME naming\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.NUM_BLOCKS_VERIFICATION = 250;\r\n\r\n\r\n/* Snapshot Parameters */\r\n\r\n/**\r\n * Maximum number of snapshots.\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.NUM_SNAPSHOTS_MAX = 20;\r\n\r\n/* Tx */\r\n\r\n/**\r\n * Initial tx fee in Satoshi\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.INITIAL_TX_FEE = 1e6; // 1M\r\n\r\n/**\r\n * changine tx fee each 6300000 blocks\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.TX_FEE_CHANGING_INTERVAL = 6300000;\r\n\r\n/**\r\n * Total number of changing tx fee\r\n * @type {number}\r\n * @constant\r\n */\r\nPolicy.TX_FEE_CHANGING_TOTAL_NUMBER = 6;\r\n\r\nClass.register(Policy);\r\n","/**\r\n * @abstract\r\n */\r\nclass Serializable {\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Serializable && BufferUtils.equals(this.serialize(), o.serialize());\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {number} negative if this is smaller than o, positive if this is larger than o, zero if equal.\r\n */\r\n compare(o) {\r\n return BufferUtils.compare(this.serialize(), o.serialize());\r\n }\r\n\r\n hashCode() {\r\n return this.toBase64();\r\n }\r\n\r\n /**\r\n * @abstract\r\n * @param {SerialBuffer} [buf]\r\n */\r\n serialize(buf) {}\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toString() {\r\n return this.toBase64();\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toBase64() {\r\n return BufferUtils.toBase64(this.serialize());\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toHex() {\r\n return BufferUtils.toHex(this.serialize());\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toBase58() {\r\n return BufferUtils.toBase58(this.serialize());\r\n }\r\n\r\n /**\r\n * @param {number}\r\n * @return {string}\r\n */\r\n toBase58Check(prefix = 0x80, suffix) {\r\n return BufferUtils.toBase58Check(this.serialize(), prefix, suffix);\r\n }\r\n}\r\n\r\nClass.register(Serializable);\r\n","class Hash extends Serializable {\r\n /**\r\n * @param {?Uint8Array} arg\r\n * @param {Hash.Algorithm} [algorithm]\r\n * @private\r\n */\r\n constructor(arg, algorithm = Hash.Algorithm.BLAKE2B) {\r\n if (arg === null) {\r\n arg = new Uint8Array(Hash.getSize(algorithm));\r\n } else {\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== Hash.getSize(algorithm)) throw new Error('Primitive: Invalid length');\r\n }\r\n super();\r\n this._obj = arg;\r\n /** @type {Hash.Algorithm} */\r\n this._algorithm = algorithm;\r\n }\r\n\r\n /**\r\n * @deprecated\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static light(arr) {\r\n return Hash.blake2b(arr);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static blake2b(arr) {\r\n return new Hash(Hash.computeBlake2b(arr), Hash.Algorithm.BLAKE2B);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @deprecated\r\n * @returns {Promise.<Hash>}\r\n */\r\n static hard(arr) {\r\n return Hash.argon2d(arr);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Promise.<Hash>}\r\n */\r\n static async argon2d(arr) {\r\n return new Hash(await (await CryptoWorker.getInstanceAsync()).computeArgon2d(arr), Hash.Algorithm.ARGON2D);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static sha256(arr) {\r\n return new Hash(Hash.computeSha256(arr), Hash.Algorithm.SHA256);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static sha512(arr) {\r\n return new Hash(Hash.computeSha512(arr), Hash.Algorithm.SHA512);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static ripemd160(arr) {\r\n return new Hash(Hash.computeRipemd160(arr), Hash.Algorithm.RIPEMD160);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static doubleHash(arr) {\r\n return Hash.ripemd160(Hash.computeSha256(arr));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @returns {Hash}\r\n */\r\n static keccak256(arr) {\r\n return new Hash(Hash.computeKeccak256(arr), Hash.Algorithm.KECCAK256);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arr\r\n * @param {Hash.Algorithm} algorithm\r\n * @returns {Hash}\r\n */\r\n static compute(arr, algorithm) {\r\n // !! The algorithms supported by this function are the allowed hash algorithms for HTLCs !!\r\n switch (algorithm) {\r\n case Hash.Algorithm.BLAKE2B: return Hash.blake2b(arr);\r\n case Hash.Algorithm.SHA256: return Hash.sha256(arr);\r\n // Hash.Algorithm.SHA512 postponed until hard-fork\r\n // Hash.Algorithm.ARGON2 intentionally omitted\r\n default: throw new Error('Invalid hash algorithm');\r\n }\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @param {Hash.Algorithm} [algorithm]\r\n * @returns {Hash}\r\n */\r\n static unserialize(buf, algorithm = Hash.Algorithm.BLAKE2B) {\r\n return new Hash(buf.read(Hash.getSize(algorithm)), algorithm);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @param {number} [begin]\r\n * @param {number} [end]\r\n * @returns {Uint8Array}\r\n */\r\n subarray(begin, end) {\r\n return this._obj.subarray(begin, end);\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return Hash.SIZE.get(this._algorithm);\r\n }\r\n\r\n /** @type {Uint8Array} */\r\n get array() {\r\n return this._obj;\r\n }\r\n\r\n /** @type {Hash.Algorithm} */\r\n get algorithm() {\r\n return this._algorithm;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Hash && o._algorithm === this._algorithm && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Hash|Uint8Array|string} hash\r\n * @param {Hash.Algorithm} algorithm\r\n * @return {Hash}\r\n */\r\n static fromAny(hash, algorithm = Hash.Algorithm.BLAKE2B) {\r\n if (hash instanceof Hash) return hash;\r\n try {\r\n return new Hash(BufferUtils.fromAny(hash, Hash.SIZE.get(algorithm)), algorithm);\r\n } catch (e) {\r\n throw new Error('Invalid hash format');\r\n }\r\n }\r\n\r\n /**\r\n * @returns {string}\r\n */\r\n toPlain() {\r\n return this.toHex();\r\n }\r\n\r\n /**\r\n * @param {string} base64\r\n * @returns {Hash}\r\n */\r\n static fromBase64(base64) {\r\n return new Hash(BufferUtils.fromBase64(base64));\r\n }\r\n\r\n /**\r\n * @param {string} hex\r\n * @returns {Hash}\r\n */\r\n static fromHex(hex) {\r\n return new Hash(BufferUtils.fromHex(hex));\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {Hash}\r\n */\r\n static fromPlain(str) {\r\n return Hash.fromString(str);\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @returns {Hash}\r\n */\r\n static fromString(str) {\r\n try {\r\n return Hash.fromHex(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n try {\r\n return Hash.fromBase64(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n throw new Error('Invalid hash format');\r\n }\r\n\r\n /**\r\n * @param {Hash} o\r\n * @returns {boolean}\r\n */\r\n static isHash(o) {\r\n return o instanceof Hash;\r\n }\r\n\r\n /**\r\n * @param {Hash.Algorithm} algorithm\r\n * @returns {number}\r\n */\r\n static getSize(algorithm) {\r\n const size = Hash.SIZE.get(algorithm);\r\n if (typeof size !== 'number') throw new Error('Invalid hash algorithm');\r\n return size;\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeBlake2b(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.BLAKE2B));\r\n NodeNative.node_blake2(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.BLAKE2B);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n const res = Module._krypton_blake2(wasmOut, wasmIn, input.length);\r\n if (res !== 0) {\r\n throw res;\r\n }\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeSha256(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.SHA256));\r\n NodeNative.node_sha256(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.SHA256);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n Module._krypton_sha256(wasmOut, wasmIn, input.length);\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeSha512(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.SHA512));\r\n NodeNative.node_sha512(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.SHA512);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n Module._krypton_sha512(wasmOut, wasmIn, input.length);\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeRipemd160(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.RIPEMD160));\r\n NodeNative.node_ripemd160(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.RIPEMD160);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n Module._ripemd160(wasmIn, input.length, wasmOut);\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} input\r\n * @returns {Uint8Array}\r\n */\r\n static computeKeccak256(input) {\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.KECCAK256));\r\n NodeNative.node_keccak256(out, new Uint8Array(input));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.KECCAK256);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmIn = Module.stackAlloc(input.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmIn, input.length).set(input);\r\n Module._keccak256(wasmIn, input.length, wasmOut);\r\n const hash = new Uint8Array(hashSize);\r\n hash.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hash;\r\n } catch (e) {\r\n Log.w(Hash, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\n/**\r\n * @enum {number}\r\n */\r\nHash.Algorithm = {\r\n BLAKE2B: 1,\r\n ARGON2D: 2,\r\n SHA256: 3,\r\n SHA512: 4,\r\n RIPEMD160: 5,\r\n KECCAK256: 6\r\n};\r\n/**\r\n * @param {Hash.Algorithm} hashAlgorithm\r\n * @return {string}\r\n */\r\nHash.Algorithm.toString = function(hashAlgorithm) {\r\n switch (hashAlgorithm) {\r\n case Hash.Algorithm.BLAKE2B: return 'blake2b';\r\n case Hash.Algorithm.ARGON2D: return 'argon2d';\r\n case Hash.Algorithm.SHA256: return 'sha256';\r\n case Hash.Algorithm.SHA512: return 'sha512';\r\n case Hash.Algorithm.RIPEMD160: return 'ripemd160';\r\n case Hash.Algorithm.KECCAK256: return 'keccak256';\r\n }\r\n throw new Error('Invalid hash algorithm');\r\n};\r\n\r\n/**\r\n * @param {Hash.Algorithm|string} algorithm\r\n * @returns {Hash.Algorithm}\r\n */\r\nHash.Algorithm.fromAny = function (algorithm) {\r\n if (typeof algorithm === 'number') return algorithm;\r\n switch (algorithm) {\r\n case 'blake2b': return Hash.Algorithm.BLAKE2B;\r\n case 'argon2d': return Hash.Algorithm.ARGON2D;\r\n case 'sha256': return Hash.Algorithm.SHA256;\r\n case 'sha512': return Hash.Algorithm.SHA512;\r\n case 'ripemd160': return Hash.Algorithm.RIPEMD160;\r\n case 'keccak256': return Hash.Algorithm.KECCAK256;\r\n }\r\n throw new Error('Invalid hash algorithm');\r\n};\r\n\r\n/**\r\n * @type {Map<Hash.Algorithm, number>}\r\n */\r\nHash.SIZE = new Map();\r\nHash.SIZE.set(Hash.Algorithm.BLAKE2B, 32);\r\nHash.SIZE.set(Hash.Algorithm.ARGON2D, 32);\r\nHash.SIZE.set(Hash.Algorithm.SHA256, 32);\r\nHash.SIZE.set(Hash.Algorithm.SHA512, 64);\r\nHash.SIZE.set(Hash.Algorithm.RIPEMD160, 20);\r\nHash.SIZE.set(Hash.Algorithm.KECCAK256, 32);\r\n\r\nHash.NULL = new Hash(new Uint8Array(32));\r\nClass.register(Hash);\r\n","class PublicKey extends Serializable {\r\n /**\r\n * @param {PublicKey} o\r\n * @returns {PublicKey}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n return new PublicKey(new Uint8Array(o._obj));\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== PublicKey.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @param {PrivateKey} privateKey\r\n * @return {PublicKey}\r\n */\r\n static derive(privateKey) {\r\n return new PublicKey(PublicKey._publicKeyDerive(privateKey._obj));\r\n }\r\n\r\n /**\r\n * @return {Uint8Array}\r\n */\r\n compress() {\r\n return PublicKey._compressPublicKey(this._obj);\r\n }\r\n\r\n /**\r\n * @param {Array.<PublicKey>} publicKeys\r\n * @return {PublicKey}\r\n */\r\n static sum(publicKeys) {\r\n publicKeys = publicKeys.slice();\r\n publicKeys.sort((a, b) => a.compare(b));\r\n return PublicKey._delinearizeAndAggregatePublicKeys(publicKeys);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {PublicKey}\r\n */\r\n static unserialize(buf) {\r\n return new PublicKey(buf.read(PublicKey.SIZE));\r\n }\r\n\r\n /**\r\n * @param {PublicKey|Uint8Array|string} o\r\n * @return {PublicKey}\r\n */\r\n static fromAny(o) {\r\n if (!o) throw new Error('Invalid public key format');\r\n if (o instanceof PublicKey) return o;\r\n try {\r\n return new PublicKey(BufferUtils.fromAny(o, PublicKey.SIZE));\r\n } catch (e) {\r\n throw new Error('Invalid public key format');\r\n }\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return PublicKey.SIZE;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof PublicKey && super.equals(o);\r\n }\r\n\r\n /**\r\n * @return {Hash}\r\n */\r\n hash() {\r\n return Hash.keccak256(this.serialize().slice(1)); // skip the type byte\r\n }\r\n\r\n /**\r\n * @param {PublicKey} o\r\n * @return {number}\r\n */\r\n compare(o) {\r\n return BufferUtils.compare(this._obj, o._obj);\r\n }\r\n\r\n /**\r\n * @return {Address}\r\n */\r\n toAddress() {\r\n return Address.fromHash(this.hash());\r\n }\r\n\r\n /**\r\n * @return {PeerId}\r\n */\r\n toPeerId() {\r\n return new PeerId(this.hash().subarray(0, 16));\r\n }\r\n\r\n /**\r\n * @param {Array.<PublicKey>} publicKeys\r\n * @returns {PublicKey}\r\n */\r\n static _delinearizeAndAggregatePublicKeys(publicKeys) {\r\n const publicKeysObj = publicKeys.map(k => k.serialize());\r\n const publicKeysHash = PublicKey._publicKeysHash(publicKeysObj);\r\n const raw = PublicKey._publicKeysDelinearizeAndAggregate(publicKeysObj, publicKeysHash);\r\n return new PublicKey(raw);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} publicKey\r\n * @returns {Uint8Array}\r\n */\r\n static _compressPublicKey(publicKey) {\r\n if (publicKey.byteLength !== PublicKey.SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const out = new Uint8Array(PublicKey.COMPRESSED_SIZE);\r\n NodeNative.node_secp256k1_pubkey_compress(out, new Uint8Array(publicKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n new Uint8Array(Module.HEAP8.buffer, rdm, 32).set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n\r\n const wasmOut = Module.stackAlloc(PublicKey.COMPRESSED_SIZE);\r\n const pubKeyBufferOut = new Uint8Array(Module.HEAP8.buffer, wasmOut, PublicKey.COMPRESSED_SIZE);\r\n \r\n const wasmIn = Module.stackAlloc(PublicKey.SIZE);\r\n const pubKeyBufferIn = new Uint8Array(Module.HEAP8.buffer, wasmIn, PublicKey.SIZE);\r\n pubKeyBufferIn.set(publicKey);\r\n\r\n Module._secp256k1_pubkey_compress(wasmOut, wasmIn);\r\n const compressed = new Uint8Array(PublicKey.COMPRESSED_SIZE);\r\n compressed.set(pubKeyBufferOut);\r\n return compressed;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} privateKey\r\n * @returns {Uint8Array}\r\n */\r\n static _publicKeyDerive(privateKey) {\r\n if (privateKey.byteLength !== PrivateKey.SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const out = new Uint8Array(PublicKey.SIZE);\r\n NodeNative.node_secp256k1_pubkey_create(out, new Uint8Array(privateKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n new Uint8Array(Module.HEAP8.buffer, rdm, 32).set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n\r\n const wasmOut = Module.stackAlloc(PublicKey.SIZE);\r\n const pubKeyBuffer = new Uint8Array(Module.HEAP8.buffer, wasmOut, PublicKey.SIZE);\r\n \r\n const wasmIn = Module.stackAlloc(privateKey.length);\r\n const privKeyBuffer = new Uint8Array(Module.HEAP8.buffer, wasmIn, PrivateKey.SIZE);\r\n privKeyBuffer.set(privateKey);\r\n\r\n Module._secp256k1_pubkey_create(wasmOut, PublicKey.SIZE, wasmIn);\r\n privKeyBuffer.fill(0);\r\n const publicKey = new Uint8Array(PublicKey.SIZE);\r\n publicKey.set(pubKeyBuffer);\r\n return publicKey;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} publicKeys\r\n * @returns {Uint8Array}\r\n */\r\n static _publicKeysHash(publicKeys) {\r\n if (publicKeys.some(publicKey => publicKey.byteLength !== PublicKey.SIZE)) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const concatenatedPublicKeys = new Uint8Array(publicKeys.length * PublicKey.SIZE);\r\n for (let i = 0; i < publicKeys.length; ++i) {\r\n concatenatedPublicKeys.set(publicKeys[i], i * PublicKey.SIZE);\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(Hash.getSize(Hash.Algorithm.SHA256));\r\n NodeNative.node_secp256k1_hash_pubkeys(out, concatenatedPublicKeys, publicKeys.length, PublicKey.SIZE);\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const hashSize = Hash.getSize(Hash.Algorithm.SHA256);\r\n const wasmOut = Module.stackAlloc(hashSize);\r\n const wasmInPublicKeys = Module.stackAlloc(concatenatedPublicKeys.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeys, concatenatedPublicKeys.length).set(concatenatedPublicKeys);\r\n Module._secp256k1_hash_pubkeys(wasmOut, wasmInPublicKeys, publicKeys.length, PublicKey.SIZE);\r\n const hashedPublicKey = new Uint8Array(hashSize);\r\n hashedPublicKey.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, hashSize));\r\n return hashedPublicKey;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} publicKey\r\n * @param {Uint8Array} publicKeysHash\r\n * @returns {Uint8Array}\r\n */\r\n static _publicKeyDelinearize(publicKey, publicKeysHash) {\r\n if (publicKey.byteLength !== PublicKey.SIZE\r\n || publicKeysHash.byteLength !== Hash.getSize(Hash.Algorithm.SHA256)) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(PublicKey.SIZE);\r\n NodeNative.node_secp256k1_delinearize_pubkey(out, new Uint8Array(publicKeysHash), new Uint8Array(publicKey));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOut = Module.stackAlloc(PublicKey.SIZE);\r\n const wasmInPublicKey = Module.stackAlloc(publicKey.length);\r\n const wasmInPublicKeysHash = Module.stackAlloc(publicKeysHash.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKey, publicKey.length).set(publicKey);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeysHash, publicKeysHash.length).set(publicKeysHash);\r\n Module._secp256k1_delinearize_pubkey(wasmOut, wasmInPublicKeysHash, wasmInPublicKey);\r\n const delinearizedPublicKey = new Uint8Array(PublicKey.SIZE);\r\n delinearizedPublicKey.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, PublicKey.SIZE));\r\n return delinearizedPublicKey;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} publicKeys\r\n * @param {Uint8Array} publicKeysHash\r\n * @returns {Uint8Array}\r\n */\r\n static _publicKeysDelinearizeAndAggregate(publicKeys, publicKeysHash) {\r\n if (publicKeys.some(publicKey => publicKey.byteLength !== PublicKey.SIZE)\r\n || publicKeysHash.byteLength !== Hash.getSize(Hash.Algorithm.SHA256)) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const concatenatedPublicKeys = new Uint8Array(publicKeys.length * PublicKey.SIZE);\r\n for (let i = 0; i < publicKeys.length; ++i) {\r\n concatenatedPublicKeys.set(publicKeys[i], i * PublicKey.SIZE);\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(PublicKey.SIZE);\r\n NodeNative.node_secp256k1_aggregate_delinearized_publkeys(out, new Uint8Array(publicKeysHash), concatenatedPublicKeys, publicKeys.length, PublicKey.SIZE);\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOut = Module.stackAlloc(PublicKey.SIZE);\r\n const wasmInPublicKeys = Module.stackAlloc(concatenatedPublicKeys.length);\r\n const wasmInPublicKeysHash = Module.stackAlloc(publicKeysHash.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeys, concatenatedPublicKeys.length).set(concatenatedPublicKeys);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInPublicKeysHash, publicKeysHash.length).set(publicKeysHash);\r\n Module._secp256k1_aggregate_delinearized_publkeys(wasmOut, wasmInPublicKeysHash, wasmInPublicKeys, publicKeys.length, PublicKey.SIZE);\r\n const aggregatePublicKey = new Uint8Array(PublicKey.SIZE);\r\n aggregatePublicKey.set(new Uint8Array(Module.HEAPU8.buffer, wasmOut, PublicKey.SIZE));\r\n return aggregatePublicKey;\r\n } catch (e) {\r\n Log.w(PublicKey, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\nPublicKey.COMPRESSED_SIZE = 33;\r\nPublicKey.SIZE = 65;\r\n\r\nClass.register(PublicKey);\r\n","class Signature extends Serializable {\r\n /**\r\n * @param {Signature} o\r\n * @returns {Signature}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n // FIXME Move this to Crypto class.\r\n const obj = new Uint8Array(o._obj);\r\n return new Signature(obj);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} arg\r\n * @private\r\n */\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== Signature.SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * @param {PrivateKey} privateKey\r\n * @param {PublicKey} publicKey\r\n * @param {Uint8Array} data\r\n * @return {Signature}\r\n */\r\n static create(privateKey, publicKey, data) {\r\n return new Signature(Signature._signatureCreate(privateKey._obj, publicKey.compress(), data));\r\n }\r\n\r\n /**\r\n * @param {Commitment} commitment\r\n * @param {Array.<PartialSignature>} signatures\r\n * @return {Signature}\r\n */\r\n static fromPartialSignatures(commitment, signatures) {\r\n const raw = Signature._combinePartialSignatures(commitment.serialize(), signatures.map(s => s.serialize()));\r\n return new Signature(raw);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Signature}\r\n */\r\n static unserialize(buf) {\r\n return new Signature(buf.read(Signature.SIZE));\r\n }\r\n\r\n /**\r\n * @param {Signature|Uint8Array|string} o\r\n * @return {Signature}\r\n */\r\n static fromAny(o) {\r\n if (!o) throw new Error('Invalid signature format');\r\n if (o instanceof Signature) return o;\r\n try {\r\n return new Signature(BufferUtils.fromAny(o, Signature.SIZE));\r\n } catch (e) {\r\n throw new Error('Invalid signature format');\r\n }\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return Signature.SIZE;\r\n }\r\n\r\n /**\r\n * @param {PublicKey} publicKey\r\n * @param {Uint8Array} data\r\n * @return {boolean}\r\n */\r\n verify(publicKey, data) {\r\n return Signature._signatureVerify(publicKey.compress(), data, this._obj);\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Signature && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} combinedCommitment\r\n * @param {Array.<Uint8Array>} partialSignatures\r\n * @returns {Uint8Array}\r\n */\r\n static _combinePartialSignatures(combinedCommitment, partialSignatures) {\r\n return Signature._aggregatePartialSignatures(partialSignatures);\r\n }\r\n\r\n /**\r\n * @param {Array.<Uint8Array>} partialSignatures\r\n * @returns {Uint8Array}\r\n */\r\n static _aggregatePartialSignatures(partialSignatures) {\r\n return partialSignatures.reduce((sigA, sigB) => {\r\n if (!sigA) return sigB;\r\n const r = sigA.slice(0, PartialSignature.HALF_SIZE);\r\n const sA = sigA.slice(PartialSignature.HALF_SIZE);\r\n const sB = sigB.slice(PartialSignature.HALF_SIZE);\r\n const sum = Signature._scalarsAdd(sA, sB);\r\n return BufferUtils.concatTypedArrays(r, sum);\r\n });\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} a\r\n * @param {Uint8Array} b\r\n * @returns {Uint8Array}\r\n */\r\n static _scalarsAdd(a, b) {\r\n if (a.byteLength !== PartialSignature.HALF_SIZE || b.byteLength !== PartialSignature.HALF_SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n if (PlatformUtils.isNodeJs()) {\r\n const out = new Uint8Array(PartialSignature.HALF_SIZE);\r\n NodeNative.node_secp256k1_add_scalars(out, new Uint8Array(a), new Uint8Array(b));\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const wasmOutSum = Module.stackAlloc(PartialSignature.HALF_SIZE);\r\n const wasmInA = Module.stackAlloc(a.length);\r\n const wasmInB = Module.stackAlloc(b.length);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInA, a.length).set(a);\r\n new Uint8Array(Module.HEAPU8.buffer, wasmInB, b.length).set(b);\r\n Module._secp256k1_add_scalars(wasmOutSum, wasmInA, wasmInB);\r\n const sum = new Uint8Array(PartialSignature.HALF_SIZE);\r\n sum.set(new Uint8Array(Module.HEAPU8.buffer, wasmOutSum, PartialSignature.HALF_SIZE));\r\n return sum;\r\n } catch (e) {\r\n Log.w(Signature, e);\r\n throw e;\r\n } finally {\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} privateKey\r\n * @param {Uint8Array} publicKey\r\n * @param {Uint8Array} message\r\n * @returns {Uint8Array}\r\n */\r\n static _signatureCreate(privateKey, publicKey, message) {\r\n if (privateKey.byteLength !== PrivateKey.SIZE || publicKey.byteLength != PublicKey.COMPRESSED_SIZE) {\r\n throw Error('Wrong buffer size.');\r\n }\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const out = new Uint8Array(Signature.SIZE);\r\n NodeNative.node_secp256k1_schnorr_sign(out, new Uint8Array(message), new Uint8Array(publicKey), new Uint8Array(privateKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return out;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n const rdmBuff = new Uint8Array(Module.HEAP8.buffer, rdm, 32);\r\n rdmBuff.set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n const wasmOutSignature = Module.stackAlloc(Signature.SIZE);\r\n const signatureBuffer = new Uint8Array(Module.HEAP8.buffer, wasmOutSignature, Signature.SIZE);\r\n const wasmInMessage = Module.stackAlloc(message.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInMessage, message.length).set(message);\r\n const wasmInPubKey = Module.stackAlloc(publicKey.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInPubKey, publicKey.length).set(publicKey);\r\n const wasmInPrivKey = Module.stackAlloc(privateKey.length);\r\n const privKeyBuffer = new Uint8Array(Module.HEAP8.buffer, wasmInPrivKey, privateKey.length);\r\n privKeyBuffer.set(privateKey);\r\n\r\n Module._secp256k1_schnorr_sign(wasmOutSignature, wasmInMessage, message.byteLength, wasmInPubKey, wasmInPrivKey);\r\n privKeyBuffer.fill(0);\r\n\r\n const signature = new Uint8Array(Signature.SIZE);\r\n signature.set(signatureBuffer);\r\n return signature;\r\n } catch (e) {\r\n Log.w(Signature, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n \r\n /**\r\n * @param {Uint8Array} publicKey\r\n * @param {Uint8Array} message\r\n * @param {Uint8Array} signature\r\n * @returns {boolean}\r\n */\r\n static _signatureVerify(publicKey, message, signature) {\r\n const randomize = new Uint8Array(32);\r\n CryptoWorker.lib.getRandomValues(randomize);\r\n if (PlatformUtils.isNodeJs()) {\r\n NodeNative.node_secp256k1_ctx_init(randomize);\r\n const res = !!NodeNative.node_secp256k1_schnorr_verify(new Uint8Array(signature), new Uint8Array(message), new Uint8Array(publicKey));\r\n NodeNative.node_secp256k1_ctx_release();\r\n return res;\r\n } else {\r\n let stackPtr;\r\n try {\r\n stackPtr = Module.stackSave();\r\n const rdm = Module.stackAlloc(32);\r\n const rdmBuff = new Uint8Array(Module.HEAP8.buffer, rdm, 32);\r\n rdmBuff.set(randomize);\r\n Module._secp256k1_ctx_init(rdm);\r\n \r\n const wasmInPubKey = Module.stackAlloc(publicKey.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInPubKey, publicKey.length).set(publicKey);\r\n const wasmInMessage = Module.stackAlloc(message.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInMessage, message.length).set(message);\r\n const wasmInSignature = Module.stackAlloc(signature.length);\r\n new Uint8Array(Module.HEAP8.buffer, wasmInSignature, signature.length).set(signature);\r\n\r\n return !!Module._secp256k1_schnorr_verify(wasmInSignature, wasmInMessage, message.byteLength, wasmInPubKey);\r\n } catch (e) {\r\n Log.w(Signature, e);\r\n throw e;\r\n } finally {\r\n Module._secp256k1_ctx_release();\r\n if (stackPtr !== undefined) Module.stackRestore(stackPtr);\r\n }\r\n }\r\n }\r\n}\r\n\r\nSignature.SIZE = 64;\r\n\r\nClass.register(Signature);\r\n","class Address extends Serializable {\r\n /**\r\n * @param {Address} o\r\n * @returns {Address}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n const obj = new Uint8Array(o._obj);\r\n return new Address(obj);\r\n }\r\n\r\n /**\r\n * @param {Hash} hash\r\n * @returns {Address}\r\n */\r\n static fromHash(hash) {\r\n return new Address(hash.subarray(-Address.SERIALIZED_SIZE));\r\n }\r\n\r\n constructor(arg) {\r\n super();\r\n if (!(arg instanceof Uint8Array)) throw new Error('Primitive: Invalid type');\r\n if (arg.length !== Address.SERIALIZED_SIZE) throw new Error('Primitive: Invalid length');\r\n this._obj = arg;\r\n }\r\n\r\n /**\r\n * Create Address object from binary form.\r\n * @param {SerialBuffer} buf Buffer to read from.\r\n * @return {Address} Newly created Account object.\r\n */\r\n static unserialize(buf) {\r\n return new Address(buf.read(Address.SERIALIZED_SIZE));\r\n }\r\n\r\n /**\r\n * Serialize this Address object into binary form.\r\n * @param {?SerialBuffer} [buf] Buffer to write to.\r\n * @return {SerialBuffer} Buffer from `buf` or newly generated one.\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.write(this._obj);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @param {number} [begin]\r\n * @param {number} [end]\r\n * @returns {Uint8Array}\r\n */\r\n subarray(begin, end) {\r\n return this._obj.subarray(begin, end);\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get serializedSize() {\r\n return Address.SERIALIZED_SIZE;\r\n }\r\n\r\n /**\r\n * @param {Serializable} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Address\r\n && super.equals(o);\r\n }\r\n\r\n /**\r\n * @param {Address|string} addr\r\n */\r\n static fromAny(addr) {\r\n if (addr instanceof Address) return addr;\r\n if (typeof addr === 'string') return Address.fromString(addr);\r\n throw new Error('Invalid address format');\r\n }\r\n\r\n /**\r\n * @returns {string}\r\n */\r\n toPlain() {\r\n return this.toUserFriendlyAddress();\r\n }\r\n\r\n static fromString(str) {\r\n try {\r\n return Address.fromUserFriendlyAddress(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n try {\r\n return Address.fromHex(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n try {\r\n return Address.fromBase64(str);\r\n } catch (e) {\r\n // Ignore\r\n }\r\n\r\n throw new Error('Invalid address format');\r\n }\r\n\r\n /**\r\n * @param {string} base64\r\n * @return {Address}\r\n */\r\n static fromBase64(base64) {\r\n return new Address(BufferUtils.fromBase64(base64));\r\n }\r\n\r\n /**\r\n * @param {string} hex\r\n * @return {Address}\r\n */\r\n static fromHex(hex) {\r\n return new Address(BufferUtils.fromHex(hex));\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @return {Address}\r\n */\r\n static fromBech32(str) {\r\n if (!this.isBech32Address(str)) {\r\n throw new Error('Invalid Bech32 Address');\r\n }\r\n\r\n return new Address(Bech32.fromBech32(str));\r\n }\r\n\r\n /**\r\n * @param {string} str\r\n * @return {Address}\r\n */\r\n static fromUserFriendlyAddress(str) {\r\n return Address.fromHex(str);\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toBech32() {\r\n return Bech32.toBech32(this.serialize());\r\n }\r\n\r\n /**\r\n * @param {boolean} [withSpaces]\r\n * @return {string}\r\n */\r\n toUserFriendlyAddress(withSpaces = true) {\r\n return this.toHex();\r\n }\r\n\r\n /**\r\n * @param {string} [addr]\r\n * @return {boolean}\r\n */\r\n static isBech32Address(addr) {\r\n return Bech32.isBech32Address(addr);\r\n }\r\n}\r\n\r\nAddress.SERIALIZED_SIZE = 20;\r\nAddress.HEX_SIZE = 40;\r\nAddress.NULL = new Address(new Uint8Array(Address.SERIALIZED_SIZE));\r\nAddress.CONTRACT_CREATION = new Address(new Uint8Array(Address.SERIALIZED_SIZE));\r\nClass.register(Address);\r\n","// This code is taken from https://github.com/sipa/bech32/tree/bdc264f84014c234e908d72026b7b780122be11f/ref/javascript\r\n// Copyright (c) 2017 Pieter Wuille\r\n//\r\n// Permission is hereby granted, free of charge, to any person obtaining a copy\r\n// of this software and associated documentation files (the \"Software\"), to deal\r\n// in the Software without restriction, including without limitation the rights\r\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n// copies of the Software, and to permit persons to whom the Software is\r\n// furnished to do so, subject to the following conditions:\r\n//\r\n// The above copyright notice and this permission notice shall be included in\r\n// all copies or substantial portions of the Software.\r\n//\r\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n// THE SOFTWARE.\r\nclass Bech32 {\r\n /**\r\n * @param {SerialBuffer} values\r\n * @returns {number}\r\n */\r\n static polymod(values) {\r\n let chk = 1;\r\n \r\n for (let p = 0; p < values.length; ++p) {\r\n const top = chk >> 25;\r\n chk = ((chk & 0x1ffffff) << 5) ^ values[p];\r\n for (let i = 0; i < 5; ++i) {\r\n if ((top >> i) & 1) {\r\n chk ^= Bech32.GENERATOR[i];\r\n }\r\n }\r\n }\r\n return chk;\r\n };\r\n \r\n /**\r\n * @param {string} hrp\r\n * @returns {SerialBuffer}\r\n */\r\n static hrpExpand(hrp) {\r\n const ret = [];\r\n let p;\r\n for (p = 0; p < hrp.length; ++p) {\r\n ret.push(hrp.charCodeAt(p) >> 5);\r\n }\r\n ret.push(0);\r\n for (p = 0; p < hrp.length; ++p) {\r\n ret.push(hrp.charCodeAt(p) & 31);\r\n }\r\n return SerialBuffer.from(ret);\r\n };\r\n\r\n /**\r\n * @param {string} hrp\r\n * @param {SerialBuffer} data\r\n * @returns {boolean}\r\n */\r\n static verifyChecksum(hrp, data) {\r\n // return Bech32.polymod(Buffer.concat([Bech32.hrpExpand(hrp), data])) === Bech32.ENCODING;\r\n return Bech32.polymod(SerialBuffer.concat([Bech32.hrpExpand(hrp), data])) === Bech32.ENCODING;\r\n }\r\n \r\n /**\r\n * @param {string} hrp\r\n * @param {SerialBuffer} data\r\n * @returns {SerialBuffer}\r\n */\r\n static createChecksum(hrp, data) {\r\n const values = SerialBuffer.concat([Bech32.hrpExpand(hrp), data, SerialBuffer.from([0, 0, 0, 0, 0, 0])]);\r\n // const values = Buffer.concat([Buffer.from(Bech32.hrpExpand(hrp)), data, Buffer.from([0, 0, 0, 0, 0, 0])]);\r\n\r\n const mod = Bech32.polymod(values) ^ Bech32.ENCODING;\r\n const ret = [];\r\n for (let p = 0; p < 6; ++p) {\r\n ret.push((mod >> (5 * (5 - p))) & 31);\r\n }\r\n return SerialBuffer.from(ret);\r\n }\r\n \r\n /**\r\n * @param {string} hrp\r\n * @param {SerialBuffer} data\r\n * @returns {string}\r\n */\r\n static bech32Encode(hrp, data) {\r\n const combined = SerialBuffer.concat([data, Bech32.createChecksum(hrp, data)]);\r\n let ret = hrp + '1';\r\n \r\n for (let p = 0; p < combined.length; ++p) {\r\n ret += Bech32.CHARSET.charAt(combined[p]);\r\n }\r\n\r\n return ret;\r\n };\r\n \r\n /**\r\n * @param {string} bechString\r\n * @returns {Object|null}\r\n */\r\n static bech32Decode(bechString) {\r\n let p;\r\n let hasLower = false;\r\n let hasUpper = false;\r\n for (p = 0; p < bechString.length; ++p) {\r\n if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {\r\n return null;\r\n }\r\n if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {\r\n hasLower = true;\r\n }\r\n if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {\r\n hasUpper = true;\r\n }\r\n }\r\n if (hasLower && hasUpper) {\r\n return null;\r\n }\r\n bechString = bechString.toLowerCase();\r\n const pos = bechString.lastIndexOf('1');\r\n if (pos < 1 || pos + 7 > bechString.length || bechString.length > 90) {\r\n return null;\r\n }\r\n const hrp = bechString.substring(0, pos);\r\n const data = [];\r\n for (p = pos + 1; p < bechString.length; ++p) {\r\n const d = Bech32.CHARSET.indexOf(bechString.charAt(p));\r\n if (d === -1) {\r\n return null;\r\n }\r\n data.push(d);\r\n }\r\n \r\n if (!Bech32.verifyChecksum(hrp, SerialBuffer.from(data))) {\r\n return null;\r\n }\r\n \r\n return { hrp, data: SerialBuffer.from(data.slice(0, data.length - 6)) };\r\n };\r\n\r\n /**\r\n * convertBits\r\n *\r\n * groups buffers of a certain width to buffers of the desired width.\r\n *\r\n * For example, converts byte buffers to buffers of maximum 5 bit numbers,\r\n * padding those numbers as necessary. Necessary for encoding addresses as bech32 ones.\r\n *\r\n * @param {SerialBuffer} data\r\n * @param {number} fromWidth\r\n * @param {number} toWidth\r\n * @param {boolean} pad\r\n * @returns {SerialBuffer|null}\r\n */\r\n static convertBits(data, fromWidth, toWidth, pad = true) {\r\n let acc = 0;\r\n let bits = 0;\r\n const ret = [];\r\n const maxv = (1 << toWidth) - 1;\r\n \r\n for (let p = 0; p < data.length; ++p) {\r\n const value = data[p];\r\n if (value < 0 || value >> fromWidth !== 0) {\r\n return null;\r\n }\r\n acc = (acc << fromWidth) | value;\r\n bits += fromWidth;\r\n while (bits >= toWidth) {\r\n bits -= toWidth;\r\n ret.push((acc >> bits) & maxv);\r\n }\r\n }\r\n\r\n if (pad) {\r\n if (bits > 0) {\r\n ret.push((acc << (toWidth - bits)) & maxv);\r\n }\r\n } else if (bits >= fromWidth || (acc << (toWidth - bits)) & maxv) {\r\n return null;\r\n }\r\n\r\n return SerialBuffer.from(ret);\r\n };\r\n\r\n /**\r\n *\r\n * bech32Encodes a canonical 20-byte address as a bech32 address.\r\n *\r\n * The expected format is bc1<address><checksum> where address and checksum\r\n * are the result of bech32 encoding a Buffer containing the address bytes.\r\n *\r\n * @param {SerialBuffer} 20 byte canonical address\r\n * @returns {string} 38 char bech32 bech32Encoded Feechain address\r\n */\r\n static toBech32(address, useHRP = Bech32.HRP) {\r\n const addrBz = Bech32.convertBits(SerialBuffer.from(address), 8, 5);\r\n\r\n if (addrBz === null) {\r\n throw new Error('Could not convert byte Buffer to 5-bit Buffer');\r\n }\r\n const version = 0; // first byte version same as bitcoin\r\n return Bech32.bech32Encode(useHRP, SerialBuffer.concat([SerialBuffer.from([version]), addrBz]));\r\n };\r\n\r\n /**\r\n * fromBech32Address\r\n *\r\n * @param {string} address - a valid bech32 address\r\n * @returns {SerialBuffer} a canonical 20-byte address\r\n */\r\n static fromBech32(address, useHRP = Bech32.HRP) {\r\n const res = Bech32.bech32Decode(address);\r\n\r\n if (res === null) {\r\n throw new Error('Invalid bech32 address');\r\n }\r\n\r\n const { hrp, data } = res;\r\n\r\n if (hrp !== useHRP) {\r\n throw new Error(`Expected hrp to be ${useHRP} but got ${hrp}`);\r\n }\r\n\r\n const buf = Bech32.convertBits(data.slice(1), 5, 8, false);\r\n\r\n if (buf === null) {\r\n throw new Error('Could not convert buffer to bytes');\r\n }\r\n \r\n return new SerialBuffer(buf);\r\n };\r\n\r\n /**\r\n *\r\n * @param {string} raw \r\n * @returns {boolean}\r\n */\r\n static isBech32Address(raw) {\r\n return !!raw.match(/^bc1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{39}/);\r\n };\r\n}\r\n\r\nBech32.ENCODING = 1; // bech32: 1, bech32m: 0x2bc830a3\r\nBech32.HRP = 'bc';\r\nBech32.CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';\r\nBech32.GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];\r\nClass.register(Bech32);\r\n","/**\r\n * @abstract\r\n */\r\nclass Account {\r\n /**\r\n * @param {Account.Type} type\r\n * @param {BigNumber|number|string} balance\r\n */\r\n constructor(type, balance) {\r\n const bigBalance = new BigNumber(balance);\r\n if (!NumberUtils.isUint8(type)) throw new Error('Malformed type');\r\n if (!NumberUtils.isUint128(bigBalance)) throw new Error('Malformed balance');\r\n\r\n /** @type {Account.Type} */\r\n this._type = type;\r\n /** @type {BigNumber} */\r\n this._balance = bigBalance;\r\n }\r\n\r\n /**\r\n * Create Account object from binary form.\r\n * @param {SerialBuffer} buf Buffer to read from.\r\n * @return {Account} Newly created Account object.\r\n */\r\n static unserialize(buf) {\r\n const type = /** @type {Account.Type} */ buf.readUint8();\r\n buf.readPos--;\r\n\r\n if (!Account.TYPE_MAP.has(type)) {\r\n throw new Error('Unknown account type');\r\n }\r\n\r\n return Account.TYPE_MAP.get(type).unserialize(buf);\r\n }\r\n\r\n /**\r\n * Serialize this Account object into binary form.\r\n * @param {?SerialBuffer} [buf] Buffer to write to.\r\n * @return {SerialBuffer} Buffer from `buf` or newly generated one.\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(this._type);\r\n buf.writeUint128(this._balance);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n get serializedSize() {\r\n return /*type*/ 1\r\n + /*balance*/ 16;\r\n }\r\n\r\n /**\r\n * Check if two Accounts are the same.\r\n * @param {Account} o Object to compare with.\r\n * @return {boolean} Set if both objects describe the same data.\r\n */\r\n equals(o) {\r\n return BufferUtils.equals(this.serialize(), o.serialize());\r\n }\r\n\r\n toString() {\r\n return `Account{type=${this._type}, balance=${this._balance.toString()}`;\r\n }\r\n\r\n /**\r\n * @param {Account|object} o\r\n */\r\n static fromAny(o) {\r\n if (o instanceof Account) return o;\r\n return Account.fromPlain(o);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n * @returns {Account}\r\n */\r\n static fromPlain(plain) {\r\n if (!plain || plain.type === undefined) throw new Error('Invalid account');\r\n const type = Account.Type.fromAny(plain.type);\r\n return Account.TYPE_MAP.get(type).fromPlain(plain);\r\n }\r\n\r\n /**\r\n * @returns {object}\r\n */\r\n toPlain() {\r\n return {\r\n type: Account.Type.toString(this.type),\r\n balance: this.balance.toString()\r\n };\r\n }\r\n\r\n /**\r\n * @type {number} Account balance\r\n */\r\n get balance() {\r\n return this._balance;\r\n }\r\n\r\n /** @type {Account.Type} */\r\n get type() {\r\n return this._type;\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @return {Account|*}\r\n */\r\n withBalance(balance) { throw new Error('Not yet implemented.'); }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {TransactionCache} transactionsCache\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert = false) {\r\n if (!revert) {\r\n const newBalance = this._balance.minus(transaction.value).minus(transaction.fee);\r\n if (newBalance.lt(0)) {\r\n throw new Account.BalanceError();\r\n }\r\n if (blockHeight < transaction.validityStartHeight\r\n || blockHeight >= transaction.validityStartHeight + Policy.TRANSACTION_VALIDITY_WINDOW) {\r\n throw new Account.ValidityError();\r\n }\r\n if (transactionsCache.containsTransaction(transaction)) {\r\n throw new Account.DoubleTransactionError();\r\n }\r\n return this.withBalance(newBalance);\r\n } else {\r\n if (blockHeight < transaction.validityStartHeight\r\n || blockHeight >= transaction.validityStartHeight + Policy.TRANSACTION_VALIDITY_WINDOW) {\r\n throw new Account.ValidityError();\r\n }\r\n return this.withBalance(this._balance.plus(transaction.value).plus(transaction.fee));\r\n }\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n if (!revert) {\r\n return this.withBalance(this._balance.plus(transaction.value));\r\n } else {\r\n const newBalance = this._balance.minus(transaction.value);\r\n if (newBalance.lt(0)) {\r\n throw new Account.BalanceError();\r\n }\r\n return this.withBalance(newBalance);\r\n }\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withContractCommand(transaction, blockHeight, revert = false) {\r\n throw new Error('Not yet implemented');\r\n }\r\n\r\n /**\r\n * @return {boolean}\r\n */\r\n isInitial() {\r\n return this === Account.INITIAL;\r\n }\r\n\r\n /**\r\n * @return {boolean}\r\n */\r\n isToBePruned() {\r\n return this._balance.eq(0) && !this.isInitial();\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} data\r\n * @return {object}\r\n */\r\n static dataToPlain(data) {\r\n return {};\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} proof\r\n * @return {object}\r\n */\r\n static proofToPlain(proof) {\r\n return {};\r\n }\r\n}\r\n\r\n/**\r\n * Enum for Account types.\r\n * Non-zero values are contracts.\r\n * @enum\r\n */\r\nAccount.Type = {\r\n /**\r\n * Basic account type.\r\n * @see {BasicAccount}\r\n */\r\n BASIC: 0,\r\n /**\r\n * Account with vesting functionality.\r\n * @see {VestingContract}\r\n */\r\n VESTING: 1,\r\n /**\r\n * Hashed Time-Locked Contract\r\n * @see {HashedTimeLockedContract}\r\n */\r\n HTLC: 2\r\n};\r\n/**\r\n * @param {Account.Type} type\r\n * @return {string}\r\n */\r\nAccount.Type.toString = function(type) {\r\n switch (type) {\r\n case Account.Type.BASIC: return 'basic';\r\n case Account.Type.VESTING: return 'vesting';\r\n case Account.Type.HTLC: return 'htlc';\r\n }\r\n throw new Error('Invalid account type');\r\n};\r\n/**\r\n * @param {Account.Type|string} type\r\n * @return {Account.Type}\r\n */\r\nAccount.Type.fromAny = function(type) {\r\n if (typeof type === 'number') return type;\r\n switch (type) {\r\n case 'basic': return Account.Type.BASIC;\r\n case 'vesting': return Account.Type.VESTING;\r\n case 'htlc': return Account.Type.HTLC;\r\n }\r\n throw new Error('Invalid account type');\r\n};\r\n/**\r\n * @type {Map.<Account.Type, {\r\n * copy: function(o: *):Account,\r\n * unserialize: function(buf: SerialBuffer):Account,\r\n * create: function(balance: BigNumber|number|string, blockHeight: number, transaction: Transaction):Account,\r\n * verifyOutgoingTransaction: function(transaction: Transaction):boolean,\r\n * verifyIncomingTransaction: function(transaction: Transaction):boolean,\r\n * fromPlain: function(o: object):Account,\r\n * dataToPlain: function(data: Uint8Array):object,\r\n * proofToPlain: function(proof: Uint8Array):object\r\n * }>}\r\n */\r\nAccount.TYPE_MAP = new Map();\r\nAccount.BalanceError = class extends Error { constructor() { super('Balance Error!'); }};\r\nAccount.DoubleTransactionError = class extends Error { constructor() { super('Double Transaction Error!'); }};\r\nAccount.ProofError = class extends Error { constructor() { super('Proof Error!'); }};\r\nAccount.ValidityError = class extends Error { constructor() { super('Validity Error!'); }};\r\nClass.register(Account);\r\n","class PrunedAccount {\r\n /**\r\n * @param {Address} address\r\n * @param {Account} account\r\n */\r\n constructor(address, account) {\r\n if (!(address instanceof Address)) throw new Error('Malformed address');\r\n\r\n /** @type {Address} */\r\n this._address = address;\r\n /** @type {Account} */\r\n this._account = account;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @returns {PrunedAccount}\r\n */\r\n static unserialize(buf) {\r\n return new PrunedAccount(Address.unserialize(buf), Account.unserialize(buf));\r\n }\r\n\r\n /**\r\n * @param {PrunedAccount|object} o\r\n * @returns {PrunedAccount}\r\n */\r\n static fromAny(o) {\r\n if (o instanceof PrunedAccount) return o;\r\n return PrunedAccount.fromPlain(o);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n */\r\n static fromPlain(plain) {\r\n return new PrunedAccount(Address.fromAny(plain.address), Account.fromAny(plain.account));\r\n }\r\n\r\n /**\r\n * @param {PrunedAccount} o\r\n * @return {number} negative if this is smaller than o, positive if this is larger than o, zero if equal.\r\n */\r\n compare(o) {\r\n return this._address.compare(o._address);\r\n }\r\n\r\n /**\r\n * @returns {Address}\r\n */\r\n get address() {\r\n return this._address;\r\n }\r\n\r\n /**\r\n * @returns {Account}\r\n */\r\n get account() {\r\n return this._account;\r\n }\r\n\r\n /**\r\n * @param buf\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n this._address.serialize(buf);\r\n this._account.serialize(buf);\r\n return this;\r\n }\r\n\r\n /**\r\n * @returns {number}\r\n */\r\n get serializedSize() {\r\n return this._address.serializedSize + this._account.serializedSize;\r\n }\r\n\r\n /**\r\n * @returns {string}\r\n */\r\n hashCode() {\r\n return this._address.hashCode();\r\n }\r\n\r\n /**\r\n * @returns {object}\r\n */\r\n toPlain() {\r\n return {\r\n address: this.address.toPlain(),\r\n account: this.account.toPlain()\r\n };\r\n }\r\n}\r\n\r\nClass.register(PrunedAccount);\r\n","/**\r\n * This is a classic account that can send all his funds and receive any transaction.\r\n * All outgoing transactions are signed using the key corresponding to this address.\r\n */\r\nclass BasicAccount extends Account {\r\n /**\r\n * @param {BasicAccount} o\r\n * @returns {BasicAccount}\r\n */\r\n static copy(o) {\r\n if (!o) return o;\r\n return new BasicAccount(o._balance);\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} [balance]\r\n */\r\n constructor(balance = 0) {\r\n super(Account.Type.BASIC, balance);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {BasicAccount}\r\n */\r\n static unserialize(buf) {\r\n const type = buf.readUint8();\r\n if (type !== Account.Type.BASIC) throw new Error('Invalid account type');\r\n\r\n const balance = buf.readUint128();\r\n return new BasicAccount(balance);\r\n }\r\n\r\n /**\r\n * @param {object} o\r\n */\r\n static fromPlain(o) {\r\n if (!o) throw new Error('Invalid account');\r\n return new BasicAccount(o.balance);\r\n }\r\n\r\n /**\r\n * Check if two Accounts are the same.\r\n * @param {Account} o Object to compare with.\r\n * @return {boolean} Set if both objects describe the same data.\r\n */\r\n equals(o) {\r\n return o instanceof BasicAccount\r\n && this._type === o._type\r\n && this._balance.eq(o._balance);\r\n }\r\n\r\n toString() {\r\n return `BasicAccount{balance=${this._balance.toString()}}`;\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyOutgoingTransaction(transaction) {\r\n return SignatureProof.verifyTransaction(transaction);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyIncomingTransaction(transaction) {\r\n if (transaction.data.byteLength > 64) return false;\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @return {Account|*}\r\n */\r\n withBalance(balance) {\r\n return new BasicAccount(balance);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n if (!revert) {\r\n const isContractCreation = transaction.hasFlag(Transaction.Flag.CONTRACT_CREATION);\r\n const isTypeChange = transaction.recipientType !== this._type;\r\n if (isContractCreation !== isTypeChange) {\r\n throw new Error('Data Error!');\r\n }\r\n }\r\n return super.withIncomingTransaction(transaction, blockHeight, revert);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withContractCommand(transaction, blockHeight, revert = false) {\r\n if (!revert && transaction.recipientType !== this._type && transaction.hasFlag(Transaction.Flag.CONTRACT_CREATION)) {\r\n // Contract creation\r\n return Account.TYPE_MAP.get(transaction.recipientType).create(this._balance, blockHeight, transaction);\r\n }\r\n return this;\r\n }\r\n\r\n /**\r\n * @return {boolean}\r\n */\r\n isInitial() {\r\n return this._balance && this._balance.eq(0);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} data\r\n * @return {object}\r\n */\r\n static dataToPlain(data) {\r\n return Account.dataToPlain(data);\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} proof\r\n * @return {object}\r\n */\r\n static proofToPlain(proof) {\r\n try {\r\n const signatureProof = SignatureProof.unserialize(new SerialBuffer(proof));\r\n return {\r\n signature: signatureProof.signature.toHex(),\r\n publicKey: signatureProof.publicKey.toHex(),\r\n signer: signatureProof.publicKey.toAddress().toPlain(),\r\n pathLength: signatureProof.merklePath.nodes.length\r\n };\r\n } catch (e) {\r\n return Account.proofToPlain(proof);\r\n }\r\n }\r\n}\r\n\r\nAccount.INITIAL = new BasicAccount(0);\r\nAccount.TYPE_MAP.set(Account.Type.BASIC, BasicAccount);\r\nClass.register(BasicAccount);\r\n","class Contract extends Account {\r\n /**\r\n * @param {Account.Type} type\r\n * @param {BigNumber|number|string} balance\r\n */\r\n constructor(type, balance) {\r\n super(type, balance);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyIncomingTransaction(transaction) {\r\n if (!transaction.recipient.equals(transaction.getContractCreationAddress())) {\r\n return false;\r\n }\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n if (!revert && transaction.hasFlag(Transaction.Flag.CONTRACT_CREATION)) {\r\n // Contract already created\r\n throw new Error('Data error');\r\n }\r\n return super.withIncomingTransaction(transaction, blockHeight, revert);\r\n }\r\n\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withContractCommand(transaction, blockHeight, revert = false) {\r\n if (revert && transaction.hasFlag(Transaction.Flag.CONTRACT_CREATION)) {\r\n // Revert contract creation\r\n return new BasicAccount(this.balance);\r\n }\r\n return this;\r\n }\r\n}\r\n\r\nClass.register(Contract);\r\n","class HashedTimeLockedContract extends Contract {\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @param {Address} sender\r\n * @param {Address} recipient\r\n * @param {Hash} hashRoot\r\n * @param {number} hashCount\r\n * @param {number} timeout\r\n * @param {BigNumber|number|string} totalAmount\r\n */\r\n constructor(balance = 0, sender = Address.NULL, recipient = Address.NULL, hashRoot = Hash.NULL, hashCount = 1, timeout = 0, totalAmount = balance) {\r\n super(Account.Type.HTLC, balance);\r\n const bigTotalAmount = new BigNumber(totalAmount);\r\n if (!(sender instanceof Address)) throw new Error('Malformed sender address');\r\n if (!(recipient instanceof Address)) throw new Error('Malformed recipient address');\r\n if (!(hashRoot instanceof Hash)) throw new Error('Malformed hashRoot');\r\n if (!NumberUtils.isUint8(hashCount) || hashCount === 0) throw new Error('Malformed hashCount');\r\n if (!NumberUtils.isUint32(timeout)) throw new Error('Malformed timeout');\r\n if (!NumberUtils.isUint128(bigTotalAmount)) throw new Error('Malformed totalAmount');\r\n\r\n /** @type {Address} */\r\n this._sender = sender;\r\n /** @type {Address} */\r\n this._recipient = recipient;\r\n /** @type {Hash} */\r\n this._hashRoot = hashRoot;\r\n /** @type {number} */\r\n this._hashCount = hashCount;\r\n /** @type {number} */\r\n this._timeout = timeout;\r\n /** @type {number} */\r\n this._totalAmount = bigTotalAmount;\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @param {number} blockHeight\r\n * @param {Transaction} transaction\r\n */\r\n static create(balance, blockHeight, transaction) {\r\n const buf = new SerialBuffer(transaction.data);\r\n\r\n const sender = Address.unserialize(buf);\r\n const recipient = Address.unserialize(buf);\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n const hashCount = buf.readUint8();\r\n const timeout = buf.readUint32();\r\n\r\n return new HashedTimeLockedContract(balance, sender, recipient, hashRoot, hashCount, timeout);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {HashedTimeLockedContract}\r\n */\r\n static unserialize(buf) {\r\n const type = buf.readUint8();\r\n if (type !== Account.Type.HTLC) throw new Error('Invalid account type');\r\n\r\n const balance = buf.readUint128();\r\n const sender = Address.unserialize(buf);\r\n const recipient = Address.unserialize(buf);\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n const hashCount = buf.readUint8();\r\n const timeout = buf.readUint32();\r\n const totalAmount = buf.readUint128();\r\n return new HashedTimeLockedContract(balance, sender, recipient, hashRoot, hashCount, timeout, totalAmount);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid account');\r\n return new HashedTimeLockedContract(plain.balance, Address.fromAny(plain.sender), Address.fromAny(plain.recipient), Hash.fromAny(plain.hashRoot, Hash.Algorithm.fromAny(plain.hashAlgorithm)), plain.hashCount, plain.timeout, plain.totalAmount);\r\n }\r\n\r\n\r\n /**\r\n * Serialize this HTLC object into binary form.\r\n * @param {?SerialBuffer} [buf] Buffer to write to.\r\n * @return {SerialBuffer} Buffer from `buf` or newly generated one.\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n super.serialize(buf);\r\n this._sender.serialize(buf);\r\n this._recipient.serialize(buf);\r\n buf.writeUint8(this._hashRoot.algorithm);\r\n this._hashRoot.serialize(buf);\r\n buf.writeUint8(this._hashCount);\r\n buf.writeUint32(this._timeout);\r\n buf.writeUint128(this._totalAmount);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n get serializedSize() {\r\n return super.serializedSize\r\n + this._sender.serializedSize\r\n + this._recipient.serializedSize\r\n + /*hashAlgorithm*/ 1\r\n + this._hashRoot.serializedSize\r\n + /*hashCount*/ 1\r\n + /*timeout*/ 4\r\n + /*totalAmount*/ 16;\r\n }\r\n\r\n /** @type {Address} */\r\n get sender() {\r\n return this._sender;\r\n }\r\n\r\n /** @type {Address} */\r\n get recipient() {\r\n return this._recipient;\r\n }\r\n\r\n /** @type {Hash.Algorithm} */\r\n get hashAlgorithm() {\r\n return this._hashRoot.algorithm;\r\n }\r\n\r\n /** @type {Hash} */\r\n get hashRoot() {\r\n return this._hashRoot;\r\n }\r\n\r\n /** @type {number} */\r\n get hashCount() {\r\n return this._hashCount;\r\n }\r\n\r\n /** @type {number} */\r\n get timeout() {\r\n return this._timeout;\r\n }\r\n\r\n /** @type {number} */\r\n get totalAmount() {\r\n return this._totalAmount;\r\n }\r\n\r\n toString() {\r\n return `HashedTimeLockedContract{balance=${this._balance.toString()}, sender=${this._sender.toUserFriendlyAddress(false)}, recipient=${this._sender.toUserFriendlyAddress(false)}, amount=${this._totalAmount.toString()}/${this._hashCount}, timeout=${this._timeout}}`;\r\n }\r\n\r\n /**\r\n * @returns {object}\r\n */\r\n toPlain() {\r\n const plain = super.toPlain();\r\n plain.sender = this.sender.toPlain();\r\n plain.recipient = this.recipient.toPlain();\r\n plain.hashAlgorithm = Hash.Algorithm.toString(this.hashRoot.algorithm);\r\n plain.hashRoot = this.hashRoot.toPlain();\r\n plain.hashCount = this.hashCount;\r\n plain.timeout = this.timeout;\r\n plain.totalAmount = this.totalAmount.toString();\r\n return plain;\r\n }\r\n\r\n /**\r\n * Check if two Accounts are the same.\r\n * @param {Account} o Object to compare with.\r\n * @return {boolean} Set if both objects describe the same data.\r\n */\r\n equals(o) {\r\n return o instanceof HashedTimeLockedContract\r\n && this._type === o._type\r\n && this._balance.eq(o._balance)\r\n && this._sender.equals(o._sender)\r\n && this._recipient.equals(o._recipient)\r\n && this._hashRoot.equals(o._hashRoot)\r\n && this._hashCount === o._hashCount\r\n && this._timeout === o._timeout\r\n && this._totalAmount.eq(o._totalAmount);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyOutgoingTransaction(transaction) {\r\n try {\r\n const buf = new SerialBuffer(transaction.proof);\r\n const type = buf.readUint8();\r\n switch (type) {\r\n case HashedTimeLockedContract.ProofType.REGULAR_TRANSFER: {\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashDepth = buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n let preImage = Hash.unserialize(buf, hashAlgorithm);\r\n\r\n // Verify that the preImage hashed hashDepth times matches the _provided_ hashRoot.\r\n for (let i = 0; i < hashDepth; ++i) {\r\n preImage = Hash.compute(preImage.array, hashAlgorithm);\r\n }\r\n if (!hashRoot.equals(preImage)) {\r\n return false;\r\n }\r\n\r\n // Signature proof of the HTLC recipient\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n break;\r\n }\r\n case HashedTimeLockedContract.ProofType.EARLY_RESOLVE: {\r\n // Signature proof of the HTLC recipient\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n\r\n // Signature proof of the HTLC creator\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n break;\r\n }\r\n case HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE:\r\n // Signature proof of the HTLC creator\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n break;\r\n default:\r\n return false;\r\n }\r\n\r\n // Reject overlong proof.\r\n if (buf.readPos !== buf.byteLength) {\r\n return false;\r\n }\r\n\r\n return true; // Accept\r\n } catch (e) {\r\n return false;\r\n }\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyIncomingTransaction(transaction) {\r\n try {\r\n const buf = new SerialBuffer(transaction.data);\r\n\r\n Address.unserialize(buf); // sender address\r\n Address.unserialize(buf); // recipient address\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n Hash.unserialize(buf, hashAlgorithm);\r\n const hashCount = buf.readUint8(); // hash count\r\n buf.readUint32(); // timeout\r\n\r\n if (hashCount === 0) {\r\n return false;\r\n }\r\n\r\n // Blacklist Argon2 hash function.\r\n if (hashAlgorithm === Hash.Algorithm.ARGON2D) {\r\n return false;\r\n }\r\n\r\n if (buf.readPos !== buf.byteLength) {\r\n return false;\r\n }\r\n\r\n return Contract.verifyIncomingTransaction(transaction);\r\n } catch (e) {\r\n return false;\r\n }\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @return {Account|*}\r\n */\r\n withBalance(balance) {\r\n return new HashedTimeLockedContract(balance, this._sender, this._recipient, this._hashRoot, this._hashCount, this._timeout, this._totalAmount);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {TransactionCache} transactionsCache\r\n * @param {boolean} [revert]\r\n * @return {Account|*}\r\n */\r\n withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert = false) {\r\n const buf = new SerialBuffer(transaction.proof);\r\n const type = buf.readUint8();\r\n let minCap = 0;\r\n switch (type) {\r\n case HashedTimeLockedContract.ProofType.REGULAR_TRANSFER: {\r\n // Check that the contract has not expired yet.\r\n if (this._timeout < blockHeight) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n // Check that the provided hashRoot is correct.\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashDepth = buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n if (!hashRoot.equals(this._hashRoot)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n // Ignore the preImage.\r\n Hash.unserialize(buf, hashAlgorithm);\r\n\r\n // Verify that the transaction is signed by the authorized recipient.\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._recipient)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n minCap = BigNumber.max(0, this._totalAmount.times(1 - (hashDepth / this._hashCount)).idiv(1));\r\n\r\n break;\r\n }\r\n case HashedTimeLockedContract.ProofType.EARLY_RESOLVE: {\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._recipient)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._sender)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n break;\r\n }\r\n case HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE: {\r\n if (this._timeout >= blockHeight) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._sender)) {\r\n throw new Account.ProofError();\r\n }\r\n\r\n break;\r\n }\r\n default:\r\n throw new Account.ProofError();\r\n }\r\n\r\n if (!revert) {\r\n const newBalance = this._balance.minus(transaction.value).minus(transaction.fee);\r\n if (newBalance.lt(minCap)) {\r\n throw new Account.BalanceError();\r\n }\r\n }\r\n\r\n return super.withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert);\r\n }\r\n\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n throw new Error('Illegal incoming transaction');\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} data\r\n * @return {object}\r\n */\r\n static dataToPlain(data) {\r\n try {\r\n const buf = new SerialBuffer(data);\r\n\r\n const sender = Address.unserialize(buf);\r\n const recipient = Address.unserialize(buf);\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n const hashCount = buf.readUint8();\r\n const timeout = buf.readUint32();\r\n\r\n return {\r\n sender: sender.toPlain(),\r\n recipient: recipient.toPlain(),\r\n hashAlgorithm: Hash.Algorithm.toString(hashAlgorithm),\r\n hashRoot: hashRoot.toPlain(),\r\n hashCount,\r\n timeout\r\n };\r\n } catch (e) {\r\n return Account.dataToPlain(data);\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} proof\r\n * @return {object}\r\n */\r\n static proofToPlain(proof) {\r\n try {\r\n const buf = new SerialBuffer(proof);\r\n const type = buf.readUint8();\r\n switch (type) {\r\n case HashedTimeLockedContract.ProofType.REGULAR_TRANSFER: {\r\n const hashAlgorithm = /** @type {Hash.Algorithm} */ buf.readUint8();\r\n const hashDepth = buf.readUint8();\r\n const hashRoot = Hash.unserialize(buf, hashAlgorithm);\r\n const preImage = Hash.unserialize(buf, hashAlgorithm);\r\n const signatureProof = SignatureProof.unserialize(buf);\r\n\r\n return {\r\n type: HashedTimeLockedContract.ProofType.toString(type),\r\n hashAlgorithm: Hash.Algorithm.toString(hashAlgorithm),\r\n hashDepth,\r\n hashRoot: hashRoot.toPlain(),\r\n preImage: preImage.toPlain(),\r\n signer: signatureProof.publicKey.toAddress().toPlain(),\r\n signature: signatureProof.signature.toHex(),\r\n publicKey: signatureProof.publicKey.toHex(),\r\n pathLength: signatureProof.merklePath.nodes.length\r\n };\r\n }\r\n case HashedTimeLockedContract.ProofType.EARLY_RESOLVE: {\r\n const signatureProof = SignatureProof.unserialize(buf);\r\n const creatorSignatureProof = SignatureProof.unserialize(buf);\r\n return {\r\n type: HashedTimeLockedContract.ProofType.toString(type),\r\n signer: signatureProof.publicKey.toAddress().toPlain(),\r\n signature: signatureProof.signature.toHex(),\r\n publicKey: signatureProof.publicKey.toHex(),\r\n pathLength: signatureProof.merklePath.nodes.length,\r\n creator: creatorSignatureProof.publicKey.toAddress().toPlain(),\r\n creatorSignature: creatorSignatureProof.signature.toHex(),\r\n creatorPublicKey: creatorSignatureProof.publicKey.toHex(),\r\n creatorPathLength: creatorSignatureProof.merklePath.nodes.length\r\n };\r\n }\r\n case HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE: {\r\n const creatorSignatureProof = SignatureProof.unserialize(buf);\r\n return {\r\n type: HashedTimeLockedContract.ProofType.toString(type),\r\n creator: creatorSignatureProof.publicKey.toAddress().toPlain(),\r\n creatorSignature: creatorSignatureProof.signature.toHex(),\r\n creatorPublicKey: creatorSignatureProof.publicKey.toHex(),\r\n creatorPathLength: creatorSignatureProof.merklePath.nodes.length\r\n };\r\n }\r\n default:\r\n return false;\r\n }\r\n } catch (e) {\r\n return Account.proofToPlain(proof);\r\n }\r\n }\r\n}\r\n\r\nHashedTimeLockedContract.ProofType = {\r\n REGULAR_TRANSFER: 1,\r\n EARLY_RESOLVE: 2,\r\n TIMEOUT_RESOLVE: 3\r\n};\r\n\r\n/**\r\n * @param {HashedTimeLockedContract.ProofType} proofType\r\n * @return {string}\r\n */\r\nHashedTimeLockedContract.ProofType.toString = function(proofType) {\r\n switch (proofType) {\r\n case HashedTimeLockedContract.ProofType.REGULAR_TRANSFER: return 'regular-transfer';\r\n case HashedTimeLockedContract.ProofType.EARLY_RESOLVE: return 'early-resolve';\r\n case HashedTimeLockedContract.ProofType.TIMEOUT_RESOLVE: return 'timeout-resolve';\r\n }\r\n throw new Error('Invalid proof type');\r\n};\r\n\r\nAccount.TYPE_MAP.set(Account.Type.HTLC, HashedTimeLockedContract);\r\nClass.register(HashedTimeLockedContract);\r\n","class VestingContract extends Contract {\r\n /**\r\n * @param {BigNumber|number|string} [balance]\r\n * @param {Address} [owner]\r\n * @param {number} [vestingStart]\r\n * @param {number} [vestingStepBlocks]\r\n * @param {BigNumber|number|string} [vestingStepAmount]\r\n * @param {BigNumber|number|string} [vestingTotalAmount]\r\n */\r\n constructor(balance = 0, owner = Address.NULL, vestingStart = 0, vestingStepBlocks = 0, vestingStepAmount = balance, vestingTotalAmount = balance) {\r\n super(Account.Type.VESTING, balance);\r\n const bigVestingStepAmount = new BigNumber(vestingStepAmount);\r\n const bigVestingTotalAmount = new BigNumber(vestingTotalAmount);\r\n if (!(owner instanceof Address)) throw new Error('Malformed owner address');\r\n if (!NumberUtils.isUint32(vestingStart)) throw new Error('Malformed vestingStart');\r\n if (!NumberUtils.isUint32(vestingStepBlocks)) throw new Error('Malformed vestingStepBlocks');\r\n if (!NumberUtils.isUint128(bigVestingStepAmount)) throw new Error('Malformed vestingStepAmount');\r\n if (!NumberUtils.isUint128(bigVestingTotalAmount)) throw new Error('Malformed vestingTotalAmount');\r\n\r\n /** @type {Address} */\r\n this._owner = owner;\r\n /** @type {number} */\r\n this._vestingStart = vestingStart;\r\n /** @type {number} */\r\n this._vestingStepBlocks = vestingStepBlocks;\r\n /** @type {BigNumber} */\r\n this._vestingStepAmount = bigVestingStepAmount;\r\n /** @type {BigNumber} */\r\n this._vestingTotalAmount = bigVestingTotalAmount;\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @param {number} blockHeight\r\n * @param {Transaction} transaction\r\n */\r\n static create(balance, blockHeight, transaction) {\r\n /** @type {number} */\r\n let vestingStart, vestingStepBlocks, vestingStepAmount, vestingTotalAmount;\r\n const buf = new SerialBuffer(transaction.data);\r\n const owner = Address.unserialize(buf);\r\n vestingTotalAmount = transaction.value;\r\n switch (transaction.data.length) {\r\n case Address.SERIALIZED_SIZE + 4:\r\n // Only block number: vest full amount at that block\r\n vestingStart = 0;\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = vestingTotalAmount;\r\n break;\r\n case Address.SERIALIZED_SIZE + 24:\r\n vestingStart = buf.readUint32();\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = buf.readUint128();\r\n break;\r\n case Address.SERIALIZED_SIZE + 40:\r\n // Create a vesting account with some instantly vested funds or additional funds considered.\r\n vestingStart = buf.readUint32();\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = buf.readUint128();\r\n vestingTotalAmount = buf.readUint128();\r\n break;\r\n default:\r\n throw new Error('Invalid transaction data');\r\n }\r\n return new VestingContract(balance, owner, vestingStart, vestingStepBlocks, vestingStepAmount, vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {VestingContract}\r\n */\r\n static unserialize(buf) {\r\n const type = buf.readUint8();\r\n if (type !== Account.Type.VESTING) throw new Error('Invalid account type');\r\n\r\n const balance = buf.readUint128();\r\n const owner = Address.unserialize(buf);\r\n const vestingStart = buf.readUint32();\r\n const vestingStepBlocks = buf.readUint32();\r\n const vestingStepAmount = buf.readUint128();\r\n const vestingTotalAmount = buf.readUint128();\r\n return new VestingContract(balance, owner, vestingStart, vestingStepBlocks, vestingStepAmount, vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid account');\r\n return new VestingContract(plain.balance, Address.fromAny(plain.owner), plain.vestingStart, plain.vestingStepBlocks, plain.vestingStepAmount, plain.vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * Serialize this VestingContract object into binary form.\r\n * @param {?SerialBuffer} [buf] Buffer to write to.\r\n * @return {SerialBuffer} Buffer from `buf` or newly generated one.\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n super.serialize(buf);\r\n this._owner.serialize(buf);\r\n buf.writeUint32(this._vestingStart);\r\n buf.writeUint32(this._vestingStepBlocks);\r\n buf.writeUint128(this._vestingStepAmount);\r\n buf.writeUint128(this._vestingTotalAmount);\r\n return buf;\r\n }\r\n\r\n /**\r\n * @return {number}\r\n */\r\n get serializedSize() {\r\n return super.serializedSize\r\n + this._owner.serializedSize\r\n + /*vestingStart*/ 4\r\n + /*vestingStepBlocks*/ 4\r\n + /*vestingStepAmount*/ 16\r\n + /*vestingTotalAmount*/ 16;\r\n }\r\n\r\n /** @type {Address} */\r\n get owner() {\r\n return this._owner;\r\n }\r\n\r\n /** @type {number} */\r\n get vestingStart() {\r\n return this._vestingStart;\r\n }\r\n\r\n /** @type {number} */\r\n get vestingStepBlocks() {\r\n return this._vestingStepBlocks;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get vestingStepAmount() {\r\n return this._vestingStepAmount;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get vestingTotalAmount() {\r\n return this._vestingTotalAmount;\r\n }\r\n\r\n toString() {\r\n return `VestingAccount{balance=${this._balance.toString()}, owner=${this._owner.toUserFriendlyAddress()}`;\r\n }\r\n\r\n /**\r\n * @returns {object}\r\n */\r\n toPlain() {\r\n const plain = super.toPlain();\r\n plain.owner = this.owner.toPlain();\r\n plain.vestingStart = this.vestingStart;\r\n plain.vestingStepBlocks = this.vestingStepBlocks;\r\n plain.vestingStepAmount = this.vestingStepAmount.toString();\r\n plain.vestingTotalAmount = this.vestingTotalAmount.toString();\r\n return plain;\r\n }\r\n\r\n /**\r\n * Check if two Accounts are the same.\r\n * @param {Account} o Object to compare with.\r\n * @return {boolean} Set if both objects describe the same data.\r\n */\r\n equals(o) {\r\n return o instanceof VestingContract\r\n && this._type === o._type\r\n && this._balance.eq(o._balance)\r\n && this._owner.equals(o._owner)\r\n && this._vestingStart === o._vestingStart\r\n && this._vestingStepBlocks === o._vestingStepBlocks\r\n && this._vestingStepAmount.eq(o._vestingStepAmount)\r\n && this._vestingTotalAmount.eq(o._vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyOutgoingTransaction(transaction) {\r\n const buf = new SerialBuffer(transaction.proof);\r\n\r\n if (!SignatureProof.unserialize(buf).verify(null, transaction.serializeContent())) {\r\n return false;\r\n }\r\n\r\n if (buf.readPos !== buf.byteLength) {\r\n return false;\r\n }\r\n\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @return {boolean}\r\n */\r\n static verifyIncomingTransaction(transaction) {\r\n switch (transaction.data.length) {\r\n case Address.SERIALIZED_SIZE + 4:\r\n case Address.SERIALIZED_SIZE + 24:\r\n case Address.SERIALIZED_SIZE + 40:\r\n return Contract.verifyIncomingTransaction(transaction);\r\n default:\r\n return false;\r\n }\r\n }\r\n\r\n /**\r\n * @param {BigNumber|number|string} balance\r\n * @return {Account|*}\r\n */\r\n withBalance(balance) {\r\n return new VestingContract(balance, this._owner, this._vestingStart, this._vestingStepBlocks, this._vestingStepAmount, this._vestingTotalAmount);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {TransactionCache} transactionsCache\r\n * @param {boolean} [revert]\r\n * @return {Account|*}\r\n */\r\n withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert = false) {\r\n if (!revert) {\r\n const minCap = this.getMinCap(blockHeight);\r\n const newBalance = this._balance.minus(transaction.value).minus(transaction.fee);\r\n if (newBalance.lt(minCap)) {\r\n throw new Account.BalanceError();\r\n }\r\n\r\n const buf = new SerialBuffer(transaction.proof);\r\n if (!SignatureProof.unserialize(buf).isSignedBy(this._owner)) {\r\n throw new Account.ProofError();\r\n }\r\n }\r\n return super.withOutgoingTransaction(transaction, blockHeight, transactionsCache, revert);\r\n }\r\n\r\n /**\r\n * @param {Transaction} transaction\r\n * @param {number} blockHeight\r\n * @param {boolean} [revert]\r\n * @return {Account}\r\n */\r\n withIncomingTransaction(transaction, blockHeight, revert = false) {\r\n throw new Error('Illegal incoming transaction');\r\n }\r\n\r\n /**\r\n * @param {number} blockHeight\r\n * @returns {number}\r\n */\r\n getMinCap(blockHeight) {\r\n return this._vestingStepBlocks && this._vestingStepAmount.gt(0)\r\n ? BigNumber.max(0, this._vestingTotalAmount.minus(this._vestingStepAmount.times(Math.floor((blockHeight - this._vestingStart) / this._vestingStepBlocks))))\r\n : new BigNumber(0);\r\n }\r\n\r\n\r\n /**\r\n * @param {Uint8Array} data\r\n * @return {object}\r\n */\r\n static dataToPlain(data) {\r\n try {\r\n let vestingStart, vestingStepBlocks, vestingStepAmount, vestingTotalAmount;\r\n const buf = new SerialBuffer(data);\r\n const owner = Address.unserialize(buf);\r\n switch (data.length) {\r\n case Address.SERIALIZED_SIZE + 4:\r\n vestingStart = 0;\r\n vestingStepBlocks = buf.readUint32();\r\n break;\r\n case Address.SERIALIZED_SIZE + 24:\r\n vestingStart = buf.readUint32();\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = buf.readUint128().toString();\r\n break;\r\n case Address.SERIALIZED_SIZE + 40:\r\n vestingStart = buf.readUint32();\r\n vestingStepBlocks = buf.readUint32();\r\n vestingStepAmount = buf.readUint128().toString();\r\n vestingTotalAmount = buf.readUint128().toString();\r\n break;\r\n default:\r\n throw new Error('Invalid transaction data');\r\n }\r\n return {\r\n owner: owner.toPlain(),\r\n vestingStart,\r\n vestingStepBlocks,\r\n vestingStepAmount,\r\n vestingTotalAmount\r\n };\r\n } catch (e) {\r\n return Account.dataToPlain(data);\r\n }\r\n }\r\n\r\n /**\r\n * @param {Uint8Array} proof\r\n * @return {object}\r\n */\r\n static proofToPlain(proof) {\r\n try {\r\n const signatureProof = SignatureProof.unserialize(new SerialBuffer(proof));\r\n return {\r\n signature: signatureProof.signature.toHex(),\r\n publicKey: signatureProof.publicKey.toHex(),\r\n signer: signatureProof.publicKey.toAddress().toPlain(),\r\n pathLength: signatureProof.merklePath.nodes.length\r\n };\r\n } catch (e) {\r\n return Account.proofToPlain(proof);\r\n }\r\n }\r\n}\r\n\r\nAccount.TYPE_MAP.set(Account.Type.VESTING, VestingContract);\r\nClass.register(VestingContract);\r\n","class BlockHeader {\r\n /**\r\n * @param {Hash} prevHash\r\n * @param {Hash} interlinkHash\r\n * @param {Hash} bodyHash\r\n * @param {Hash} accountsHash\r\n * @param {number} nBits\r\n * @param {number} height\r\n * @param {number} timestamp\r\n * @param {number} nonce\r\n * @param {number} version\r\n */\r\n constructor(prevHash, interlinkHash, bodyHash, accountsHash, nBits, height, timestamp, nonce, version = BlockHeader.CURRENT_VERSION) {\r\n if (!NumberUtils.isUint16(version)) throw new Error('Malformed version');\r\n if (!Hash.isHash(prevHash)) throw new Error('Malformed prevHash');\r\n if (!Hash.isHash(interlinkHash)) throw new Error('Malformed interlinkHash');\r\n if (!Hash.isHash(bodyHash)) throw new Error('Malformed bodyHash');\r\n if (!Hash.isHash(accountsHash)) throw new Error('Malformed accountsHash');\r\n if (!NumberUtils.isUint32(nBits) || !BlockUtils.isValidCompact(nBits)) throw new Error('Malformed nBits');\r\n if (!NumberUtils.isUint32(height)) throw new Error('Invalid height');\r\n if (!NumberUtils.isUint32(timestamp)) throw new Error('Malformed timestamp');\r\n if (!NumberUtils.isUint32(nonce)) throw new Error('Malformed nonce');\r\n\r\n /** @type {number} */\r\n this._version = version;\r\n /** @type {Hash} */\r\n this._prevHash = prevHash;\r\n /** @type {Hash} */\r\n this._interlinkHash = interlinkHash;\r\n /** @type {Hash} */\r\n this._bodyHash = bodyHash;\r\n /** @type {Hash} */\r\n this._accountsHash = accountsHash;\r\n /** @type {number} */\r\n this._nBits = nBits;\r\n /** @type {number} */\r\n this._height = height;\r\n /** @type {number} */\r\n this._timestamp = timestamp;\r\n /** @type {number} */\r\n this._nonce = nonce;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @returns {BlockHeader}\r\n */\r\n static unserialize(buf) {\r\n const version = buf.readUint16();\r\n if (!BlockHeader.SUPPORTED_VERSIONS.includes(version)) throw new Error(`Unsupported block version ${version}`);\r\n const prevHash = Hash.unserialize(buf);\r\n const interlinkHash = Hash.unserialize(buf);\r\n const bodyHash = Hash.unserialize(buf);\r\n const accountsHash = Hash.unserialize(buf);\r\n const nBits = buf.readUint32();\r\n const height = buf.readUint32();\r\n const timestamp = buf.readUint32();\r\n const nonce = buf.readUint32();\r\n return new BlockHeader(prevHash, interlinkHash, bodyHash, accountsHash, nBits, height, timestamp, nonce, version);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint16(this._version);\r\n this._prevHash.serialize(buf);\r\n this._interlinkHash.serialize(buf);\r\n this._bodyHash.serialize(buf);\r\n this._accountsHash.serialize(buf);\r\n buf.writeUint32(this._nBits);\r\n buf.writeUint32(this._height);\r\n buf.writeUint32(this._timestamp);\r\n buf.writeUint32(this._nonce);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return /*version*/ 2\r\n + this._prevHash.serializedSize\r\n + this._interlinkHash.serializedSize\r\n + this._bodyHash.serializedSize\r\n + this._accountsHash.serializedSize\r\n + /*nBits*/ 4\r\n + /*height*/ 4\r\n + /*timestamp*/ 4\r\n + /*nonce*/ 4;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {Promise.<boolean>}\r\n */\r\n async verifyProofOfWork(buf) {\r\n const pow = await this.pow(buf);\r\n return BlockUtils.isProofOfWork(pow, this.target);\r\n }\r\n\r\n /**\r\n * @param {BlockHeader} prevHeader\r\n * @returns {boolean}\r\n */\r\n isImmediateSuccessorOf(prevHeader) {\r\n // Check that the height is one higher than the previous height.\r\n if (this.height !== prevHeader.height + 1) {\r\n return false;\r\n }\r\n\r\n // Check that the timestamp is greater or equal to the predecessor's timestamp.\r\n if (this.timestamp < prevHeader.timestamp) {\r\n return false;\r\n }\r\n\r\n // Check that the hash of the predecessor block equals prevHash.\r\n const prevHash = prevHeader.hash();\r\n if (!this.prevHash.equals(prevHash)) {\r\n return false;\r\n }\r\n\r\n // Everything checks out.\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {Hash}\r\n */\r\n hash(buf) {\r\n this._hash = this._hash || Hash.light(this.serialize(buf));\r\n return this._hash;\r\n }\r\n \r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {Promise.<Hash>}\r\n */\r\n async pow(buf) {\r\n this._pow = this._pow || await Hash.hard(this.serialize(buf));\r\n return this._pow;\r\n }\r\n\r\n /**\r\n * @param {BlockHeader|*} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof BlockHeader\r\n && this._prevHash.equals(o.prevHash)\r\n && this._interlinkHash.equals(o.interlinkHash)\r\n && this._bodyHash.equals(o.bodyHash)\r\n && this._accountsHash.equals(o.accountsHash)\r\n && this._nBits === o.nBits\r\n && this._height === o.height\r\n && this._timestamp === o.timestamp\r\n && this._nonce === o.nonce;\r\n }\r\n\r\n /**\r\n * @returns {string}\r\n */\r\n toString() {\r\n return 'BlockHeader{'\r\n + `prevHash=${this._prevHash}, `\r\n + `interlinkHash=${this._interlinkHash}, `\r\n + `bodyHash=${this._bodyHash}, `\r\n + `accountsHash=${this._accountsHash}, `\r\n + `nBits=${this._nBits.toString(16)}, `\r\n + `height=${this._height}, `\r\n + `timestamp=${this._timestamp}, `\r\n + `nonce=${this._nonce}`\r\n + '}';\r\n }\r\n\r\n /** @type {number} */\r\n get version() {\r\n return this._version;\r\n }\r\n\r\n /** @type {Hash} */\r\n get prevHash() {\r\n return this._prevHash;\r\n }\r\n\r\n /** @type {Hash} */\r\n get interlinkHash() {\r\n return this._interlinkHash;\r\n }\r\n\r\n /** @type {Hash} */\r\n get bodyHash() {\r\n return this._bodyHash;\r\n }\r\n\r\n /** @type {Hash} */\r\n get accountsHash() {\r\n return this._accountsHash;\r\n }\r\n\r\n /** @type {number} */\r\n get nBits() {\r\n return this._nBits;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get target() {\r\n return BlockUtils.compactToTarget(this._nBits);\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get difficulty() {\r\n return BlockUtils.compactToDifficulty(this._nBits);\r\n }\r\n\r\n /** @type {number} */\r\n get height() {\r\n return this._height;\r\n }\r\n\r\n /** @type {number} */\r\n get timestamp() {\r\n return this._timestamp;\r\n }\r\n\r\n /** @type {number} */\r\n get nonce() {\r\n return this._nonce;\r\n }\r\n\r\n // XXX The miner changes the nonce of an existing BlockHeader during the\r\n // mining process.\r\n /** @type {number} */\r\n set nonce(n) {\r\n this._nonce = n;\r\n this._hash = null;\r\n this._pow = null;\r\n }\r\n}\r\nBlockHeader.Version = {\r\n V1: 1\r\n};\r\nBlockHeader.CURRENT_VERSION = BlockHeader.Version.V1;\r\nBlockHeader.SUPPORTED_VERSIONS = [\r\n BlockHeader.Version.V1\r\n];\r\nBlockHeader.SERIALIZED_SIZE = 146;\r\nClass.register(BlockHeader);\r\n","class BlockInterlink {\r\n /**\r\n * @param {Array.<Hash>} hashes\r\n * @param {Hash} prevHash\r\n * @returns {{repeatBits: Uint8Array, compressed: Array.<Hash>}}\r\n * @protected\r\n */\r\n static _compress(hashes, prevHash) {\r\n const count = hashes.length;\r\n const repeatBitsSize = Math.ceil(count / 8);\r\n const repeatBits = new Uint8Array(repeatBitsSize);\r\n\r\n let lastHash = prevHash;\r\n const compressed = [];\r\n for (let i = 0; i < count; i++) {\r\n const hash = hashes[i];\r\n if (!hash.equals(lastHash)) {\r\n compressed.push(hash);\r\n lastHash = hash;\r\n } else {\r\n repeatBits[Math.floor(i / 8)] |= 0x80 >>> (i % 8);\r\n }\r\n }\r\n\r\n return {repeatBits, compressed};\r\n }\r\n\r\n /**\r\n * @param {Array.<Hash>} hashes\r\n * @param {Hash} [prevHash]\r\n * @param {Uint8Array} [repeatBits]\r\n * @param {Array.<Hash>} [compressed]\r\n */\r\n constructor(hashes, prevHash, repeatBits, compressed) {\r\n if (!Array.isArray(hashes) || !NumberUtils.isUint8(hashes.length)\r\n || hashes.some(it => !(it instanceof Hash))) throw new Error('Malformed hashes');\r\n if ((repeatBits || compressed) && !(repeatBits && compressed)) throw new Error('Malformed repeatBits/compressed');\r\n if (!prevHash && !repeatBits) throw new Error('Either prevHash or repeatBits/compressed required');\r\n\r\n if (!repeatBits) {\r\n ({repeatBits, compressed} = BlockInterlink._compress(hashes, prevHash));\r\n }\r\n\r\n /** @type {Array.<Hash>} */\r\n this._hashes = hashes;\r\n /** @type {Uint8Array} */\r\n this._repeatBits = repeatBits;\r\n /** @type {Array.<Hash>} */\r\n this._compressed = compressed;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @param {Hash} prevHash\r\n * @returns {BlockInterlink}\r\n */\r\n static unserialize(buf, prevHash) {\r\n const count = buf.readUint8();\r\n const repeatBitsSize = Math.ceil(count / 8);\r\n const repeatBits = buf.read(repeatBitsSize);\r\n\r\n let hash = prevHash;\r\n const hashes = [];\r\n const compressed = [];\r\n for (let i = 0; i < count; i++) {\r\n const repeated = (repeatBits[Math.floor(i / 8)] & (0x80 >>> (i % 8))) !== 0;\r\n if (!repeated) {\r\n hash = Hash.unserialize(buf);\r\n compressed.push(hash);\r\n }\r\n hashes.push(hash);\r\n }\r\n\r\n return new BlockInterlink(hashes, prevHash, repeatBits, compressed);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(this._hashes.length);\r\n buf.write(this._repeatBits);\r\n for (const hash of this._compressed) {\r\n hash.serialize(buf);\r\n }\r\n return buf;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get serializedSize() {\r\n return /*count*/ 1\r\n + this._repeatBits.length\r\n + this._compressed.reduce((sum, hash) => sum + hash.serializedSize, 0);\r\n }\r\n\r\n /**\r\n * @param {BlockInterlink|*} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof BlockInterlink\r\n && this._hashes.length === o._hashes.length\r\n && this._hashes.every((hash, i) => hash.equals(o.hashes[i]));\r\n }\r\n\r\n /**\r\n * @returns {Hash}\r\n */\r\n hash() {\r\n if (!this._hash) {\r\n this._hash = MerkleTree.computeRoot([this._repeatBits, GenesisConfig.GENESIS_HASH, ...this._compressed]);\r\n }\r\n return this._hash;\r\n }\r\n\r\n /**\r\n * @type {Array.<Hash>}\r\n */\r\n get hashes() {\r\n return this._hashes;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get length() {\r\n return this._hashes.length;\r\n }\r\n}\r\nClass.register(BlockInterlink);\r\n","class BlockBody {\r\n /**\r\n * @param {Uint8Array} extraData\r\n * @returns {number}\r\n */\r\n static getMetadataSize(extraData) {\r\n return Address.SERIALIZED_SIZE\r\n + /*extraDataLength*/ 1\r\n + extraData.byteLength\r\n + /*transactionsLength*/ 2\r\n + /*prunedAccountsLength*/ 2;\r\n }\r\n\r\n /**\r\n * @param {Address} minerAddr\r\n * @param {Array.<Transaction>} transactions\r\n * @param {Uint8Array} [extraData]\r\n * @param {Array.<PrunedAccount>} prunedAccounts\r\n */\r\n constructor(minerAddr, transactions, extraData = new Uint8Array(0), prunedAccounts = []) {\r\n if (!(minerAddr instanceof Address)) throw new Error('Malformed minerAddr');\r\n if (!Array.isArray(transactions) || transactions.some(it => !(it instanceof Transaction))) throw new Error('Malformed transactions');\r\n if (!(extraData instanceof Uint8Array) || !NumberUtils.isUint8(extraData.byteLength)) throw new Error('Malformed extraData');\r\n\r\n /** @type {Address} */\r\n this._minerAddr = minerAddr;\r\n /** @type {Uint8Array} */\r\n this._extraData = extraData;\r\n /** @type {Array.<Transaction>} */\r\n this._transactions = transactions;\r\n /** @type {Array.<PrunedAccount>} */\r\n this._prunedAccounts = prunedAccounts;\r\n /** @type {Hash} */\r\n this._hash = null;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {BlockBody}\r\n */\r\n static unserialize(buf) {\r\n const minerAddr = Address.unserialize(buf);\r\n const extraDataLength = buf.readUint8();\r\n const extraData = buf.read(extraDataLength);\r\n const numTransactions = buf.readUint16();\r\n const transactions = new Array(numTransactions);\r\n for (let i = 0; i < numTransactions; i++) {\r\n transactions[i] = Transaction.unserialize(buf);\r\n }\r\n const numPrunedAccounts = buf.readUint16();\r\n const prunedAccounts = [];\r\n for (let i = 0; i < numPrunedAccounts; i++) {\r\n prunedAccounts.push(PrunedAccount.unserialize(buf));\r\n }\r\n return new BlockBody(minerAddr, transactions, extraData, prunedAccounts);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n this._minerAddr.serialize(buf);\r\n buf.writeUint8(this._extraData.byteLength);\r\n buf.write(this._extraData);\r\n buf.writeUint16(this._transactions.length);\r\n for (const tx of this._transactions) {\r\n tx.serialize(buf);\r\n }\r\n buf.writeUint16(this._prunedAccounts.length);\r\n for (const acc of this._prunedAccounts) {\r\n acc.serialize(buf);\r\n }\r\n return buf;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get serializedSize() {\r\n let size = this._minerAddr.serializedSize\r\n + /*extraDataLength*/ 1\r\n + this._extraData.byteLength\r\n + /*transactionsLength*/ 2\r\n + /*prunedAccountsLength*/ 2;\r\n for (const tx of this._transactions) {\r\n size += tx.serializedSize;\r\n }\r\n size += this._prunedAccounts.reduce((sum, acc) => sum + acc.serializedSize, 0);\r\n return size;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n verify() {\r\n /** @type {Transaction} */\r\n let previousTx = null;\r\n for (const tx of this._transactions) {\r\n // Ensure transactions are ordered and unique.\r\n if (previousTx && previousTx.compareBlockOrder(tx) >= 0) {\r\n Log.w(BlockBody, 'Invalid block - transactions not ordered.');\r\n return false;\r\n }\r\n previousTx = tx;\r\n\r\n // Check that all transactions are valid.\r\n if (!tx.verify()) {\r\n Log.w(BlockBody, 'Invalid block - invalid transaction');\r\n return false;\r\n }\r\n }\r\n\r\n let previousAcc = null;\r\n for (const acc of this._prunedAccounts) {\r\n // Ensure pruned accounts are ordered and unique.\r\n if (previousAcc && previousAcc.compare(acc) >= 0) {\r\n Log.w(BlockBody, 'Invalid block - pruned accounts not ordered.');\r\n return false;\r\n }\r\n previousAcc = acc;\r\n \r\n // Check that pruned accounts are actually supposed to be pruned\r\n if (!acc.account.isToBePruned()) {\r\n Log.w(BlockBody, 'Invalid block - invalid pruned account');\r\n return false;\r\n }\r\n }\r\n\r\n // Everything checks out.\r\n return true;\r\n }\r\n\r\n /**\r\n * @returns {Array}\r\n */\r\n getMerkleLeafs() {\r\n return [this._minerAddr, this._extraData, ...this._transactions, ...this.prunedAccounts];\r\n }\r\n\r\n /**\r\n * @return {Hash}\r\n */\r\n hash() {\r\n if (!this._hash) {\r\n this._hash = MerkleTree.computeRoot(this.getMerkleLeafs());\r\n }\r\n return this._hash;\r\n }\r\n\r\n /**\r\n * @param {BlockBody} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof BlockBody\r\n && this._minerAddr.equals(o.minerAddr)\r\n && BufferUtils.equals(this._extraData, o.extraData)\r\n && this._transactions.length === o.transactions.length\r\n && this._transactions.every((tx, i) => tx.equals(o.transactions[i]));\r\n }\r\n\r\n /**\r\n * @return {Array.<Address>}\r\n */\r\n getAddresses() {\r\n const addresses = [this._minerAddr];\r\n for (const tx of this._transactions) {\r\n addresses.push(tx.sender, tx.recipient);\r\n }\r\n return addresses;\r\n }\r\n\r\n /** @type {Uint8Array} */\r\n get extraData() {\r\n return this._extraData;\r\n }\r\n\r\n /** @type {Address} */\r\n get minerAddr() {\r\n return this._minerAddr;\r\n }\r\n\r\n /** @type {Array.<Transaction>} */\r\n get transactions() {\r\n return this._transactions;\r\n }\r\n\r\n /** @type {number} */\r\n get transactionCount() {\r\n return this._transactions.length;\r\n }\r\n\r\n /** @type {Array.<PrunedAccount>} */\r\n get prunedAccounts() {\r\n return this._prunedAccounts;\r\n }\r\n}\r\n\r\nClass.register(BlockBody);\r\n","class BlockUtils {\r\n /**\r\n * @param {number} compact\r\n * @returns {BigNumber}\r\n */\r\n static compactToTarget(compact) {\r\n return new BigNumber(compact & 0xffffff).times(new BigNumber(2).pow(8 * Math.max((compact >> 24) - 3, 0)));\r\n }\r\n\r\n /**\r\n * @param {BigNumber} target\r\n * @returns {number}\r\n */\r\n static targetToCompact(target) {\r\n if (!target.isFinite() || target.isNaN()) throw new Error('Invalid Target');\r\n\r\n // Divide to get first byte\r\n let size = Math.max(Math.ceil(Math.log2(target.toNumber()) / 8), 1);\r\n const firstByte = target / Math.pow(2, (size - 1) * 8);\r\n\r\n // If the first (most significant) byte is greater than 127 (0x7f),\r\n // prepend a zero byte.\r\n if (firstByte >= 0x80 && size >= 3) {\r\n size++;\r\n }\r\n\r\n // The first byte of the 'compact' format is the number of bytes,\r\n // including the prepended zero if it's present.\r\n // The following three bytes are the first three bytes of the above\r\n // representation. If less than three bytes are present, then one or\r\n // more of the last bytes of the compact representation will be zero.\r\n return (size << 24) + ((target / Math.pow(2, Math.max(size - 3, 0) * 8)) & 0xffffff);\r\n }\r\n\r\n /**\r\n * @param {BigNumber} target\r\n * @returns {number}\r\n */\r\n static getTargetHeight(target) {\r\n // Precision loss should be ok here.\r\n return Math.ceil(Math.log2(target.toNumber()));\r\n }\r\n\r\n /**\r\n * @param {BigNumber} target\r\n * @returns {number}\r\n */\r\n static getTargetDepth(target) {\r\n return BlockUtils.getTargetHeight(Policy.BLOCK_TARGET_MAX) - BlockUtils.getTargetHeight(target);\r\n }\r\n\r\n /**\r\n * @param {number} compact\r\n * @returns {BigNumber}\r\n */\r\n static compactToDifficulty(compact) {\r\n return Policy.BLOCK_TARGET_MAX.div(BlockUtils.compactToTarget(compact));\r\n }\r\n\r\n /**\r\n * @param {BigNumber} difficulty\r\n * @returns {number}\r\n */\r\n static difficultyToCompact(difficulty) {\r\n return BlockUtils.targetToCompact(BlockUtils.difficultyToTarget(difficulty));\r\n }\r\n\r\n /**\r\n * @param {BigNumber} difficulty\r\n * @returns {BigNumber}\r\n */\r\n static difficultyToTarget(difficulty) {\r\n return Policy.BLOCK_TARGET_MAX.div(difficulty);\r\n }\r\n\r\n /**\r\n * @param {BigNumber} target\r\n * @returns {BigNumber}\r\n */\r\n static targetToDifficulty(target) {\r\n return Policy.BLOCK_TARGET_MAX.div(target);\r\n }\r\n\r\n /**\r\n * @param {Hash} hash\r\n * @returns {BigNumber}\r\n */\r\n static hashToTarget(hash) {\r\n return new BigNumber(hash.toHex(), 16);\r\n }\r\n\r\n /**\r\n * @param {Hash} hash\r\n * @returns {BigNumber}\r\n */\r\n static realDifficulty(hash) {\r\n return BlockUtils.targetToDifficulty(BlockUtils.hashToTarget(hash));\r\n }\r\n\r\n /**\r\n * @param {Hash} hash\r\n * @returns {number}\r\n */\r\n static getHashDepth(hash) {\r\n return BlockUtils.getTargetDepth(BlockUtils.hashToTarget(hash));\r\n }\r\n\r\n /**\r\n * @param {Hash} hash\r\n * @param {BigNumber} target\r\n * @returns {boolean}\r\n */\r\n static isProofOfWork(hash, target) {\r\n return new BigNumber(hash.toHex(), 16).lte(target);\r\n }\r\n\r\n /**\r\n * @param {number} compact\r\n * @returns {boolean}\r\n */\r\n\r\n static isValidCompact(compact) {\r\n return BlockUtils.isValidTarget(BlockUtils.compactToTarget(compact));\r\n }\r\n\r\n /**\r\n * @param {?BigNumber} target\r\n * @returns {boolean}\r\n */\r\n static isValidTarget(target) {\r\n return target !== null && target.gte(1) && target.lte(Policy.BLOCK_TARGET_MAX);\r\n }\r\n\r\n /**\r\n * @param {BlockHeader} headBlock\r\n * @param {BlockHeader} tailBlock\r\n * @param {BigNumber} deltaTotalDifficulty\r\n * @returns {BigNumber}\r\n */\r\n static getNextTarget(headBlock, tailBlock, deltaTotalDifficulty) {\r\n const blockWindow = Policy.difficultyBlockWindow(headBlock.height);\r\n Assert.that(\r\n (headBlock.height - tailBlock.height === blockWindow)\r\n || (headBlock.height <= blockWindow && tailBlock.height === 1),\r\n `Tail and head block must be ${blockWindow} blocks apart`);\r\n\r\n let actualTime = headBlock.timestamp - tailBlock.timestamp;\r\n\r\n // Simulate that the Policy.BLOCK_TIME was achieved for the blocks before the genesis block, i.e. we simulate\r\n // a sliding window that starts before the genesis block. Assume difficulty = 1 for these blocks.\r\n if (headBlock.height <= blockWindow) {\r\n actualTime += (blockWindow - headBlock.height + 1) * Policy.INITIAL_BLOCK_TIME;\r\n deltaTotalDifficulty = deltaTotalDifficulty.plus(blockWindow - headBlock.height + 1);\r\n }\r\n\r\n // Compute the target adjustment factor.\r\n const expectedTime = blockWindow * Policy.blockTime(headBlock.height);\r\n let adjustment = actualTime / expectedTime;\r\n\r\n if (headBlock.height >= Policy.SECOND_FORKING_FOR_BLOCK_DIFFICULTY) {\r\n // for block equal or greater than 1132333 (mainnet)\r\n adjustment = Math.max(adjustment, 1 / Policy.SECOND_DIFFICULTY_MAX_ADJUSTMENT_FACTOR);\r\n adjustment = Math.min(adjustment, 1 / Policy.SECOND_DIFFICULTY_MIN_ADJUSTMENT_FACTOR);\r\n } else if (headBlock.height >= Policy.FORKING_FOR_BLOCK_DIFFICULTY_BLOCK_SIZE) {\r\n // for block equal or greater than 1124816 (mainnet)\r\n adjustment = Math.max(adjustment, 1 / Policy.NEW_DIFFICULTY_MAX_ADJUSTMENT_FACTOR);\r\n adjustment = Math.min(adjustment, 1 / Policy.NEW_DIFFICULTY_MIN_ADJUSTMENT_FACTOR);\r\n } else {\r\n // forking: from block 2 to block less than 1124816 mainnet\r\n // Clamp the adjustment factor to [1 / MAX_ADJUSTMENT_FACTOR, MAX_ADJUSTMENT_FACTOR].\r\n adjustment = Math.max(adjustment, 1 / Policy.DIFFICULTY_MAX_ADJUSTMENT_FACTOR);\r\n adjustment = Math.min(adjustment, Policy.DIFFICULTY_MAX_ADJUSTMENT_FACTOR);\r\n }\r\n\r\n // Compute the next target.\r\n const averageDifficulty = deltaTotalDifficulty.div(blockWindow);\r\n const averageTarget = BlockUtils.difficultyToTarget(averageDifficulty);\r\n let nextTarget = averageTarget.times(adjustment);\r\n\r\n // Make sure the target is below or equal the maximum allowed target (difficulty 1).\r\n // Also enforce a minimum target of 1.\r\n nextTarget = BigNumber.min(nextTarget, Policy.BLOCK_TARGET_MAX);\r\n nextTarget = BigNumber.max(nextTarget, 1);\r\n\r\n // XXX Reduce target precision to nBits precision.\r\n const nBits = BlockUtils.targetToCompact(nextTarget);\r\n return BlockUtils.compactToTarget(nBits);\r\n }\r\n}\r\nClass.register(BlockUtils);\r\n","class Block {\r\n /**\r\n * @param {BlockHeader} header\r\n * @param {BlockInterlink} interlink\r\n * @param {BlockBody} [body]\r\n */\r\n constructor(header, interlink, body) {\r\n if (!(header instanceof BlockHeader)) throw new Error('Malformed header');\r\n if (!(interlink instanceof BlockInterlink)) throw new Error('Malformed interlink');\r\n if (body && !(body instanceof BlockBody)) throw new Error('Malformed body');\r\n\r\n /** @type {BlockHeader} */\r\n this._header = header;\r\n /** @type {BlockInterlink} */\r\n this._interlink = interlink;\r\n /** @type {BlockBody} */\r\n this._body = body;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @returns {Block}\r\n */\r\n static unserialize(buf) {\r\n const header = BlockHeader.unserialize(buf);\r\n const interlink = BlockInterlink.unserialize(buf, header.prevHash);\r\n\r\n let body = undefined;\r\n const bodyPresent = buf.readUint8();\r\n if (bodyPresent) {\r\n body = BlockBody.unserialize(buf);\r\n }\r\n\r\n return new Block(header, interlink, body);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n this._header.serialize(buf);\r\n this._interlink.serialize(buf);\r\n\r\n if (this._body) {\r\n buf.writeUint8(1);\r\n this._body.serialize(buf);\r\n } else {\r\n buf.writeUint8(0);\r\n }\r\n\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return this._header.serializedSize\r\n + this._interlink.serializedSize\r\n + /*bodyPresent*/ 1\r\n + (this._body ? this._body.serializedSize : 0);\r\n }\r\n\r\n /**\r\n * @param {Time} time\r\n * @returns {Promise.<boolean>}\r\n */\r\n async verify(time) {\r\n if (this._valid === undefined) {\r\n if (this.isLight() || this.body.transactions.length < 150 || !IWorker.areWorkersAsync) {\r\n // worker overhead doesn't pay off for small transaction numbers\r\n this._valid = await this._verify(time.now());\r\n } else {\r\n const transactionValid = this.body.transactions.map(t => t._valid);\r\n const worker = await CryptoWorker.getInstanceAsync();\r\n const {valid, pow, interlinkHash, bodyHash} = await worker.blockVerify(this.serialize(),\r\n transactionValid, time.now(), GenesisConfig.GENESIS_HASH.serialize(), GenesisConfig.NETWORK_ID);\r\n this._valid = valid;\r\n this.header._pow = Hash.unserialize(new SerialBuffer(pow));\r\n this.interlink._hash = Hash.unserialize(new SerialBuffer(interlinkHash));\r\n this.body._hash = Hash.unserialize(new SerialBuffer(bodyHash));\r\n }\r\n }\r\n return this._valid;\r\n }\r\n\r\n /**\r\n * @param {number} timeNow\r\n * @returns {Promise.<boolean>}\r\n */\r\n async _verify(timeNow) {\r\n // Check that the timestamp is not too far into the future.\r\n if (this._header.timestamp * 1000 > timeNow + Block.TIMESTAMP_DRIFT_MAX * 1000) {\r\n Log.w(Block, 'Invalid block - timestamp too far in the future');\r\n return false;\r\n }\r\n\r\n // Check that the header hash matches the difficulty.\r\n if (!(await this._header.verifyProofOfWork())) {\r\n Log.w(Block, 'Invalid block - PoW verification failed');\r\n return false;\r\n }\r\n\r\n // Check that the maximum block size is not exceeded.\r\n if (this.serializedSize > Policy.blockSize(this.height)) {\r\n Log.w(Block, 'Invalid block - max block size exceeded');\r\n return false;\r\n }\r\n\r\n // Verify that the interlink is valid.\r\n if (!this._verifyInterlink()) {\r\n return false;\r\n }\r\n\r\n // XXX Verify the body only if it is present.\r\n if (this.isFull() && !this._verifyBody()) {\r\n return false;\r\n }\r\n\r\n // Everything checks out.\r\n return true;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n * @private\r\n */\r\n _verifyInterlink() {\r\n // Skip check for genesis block due to the cyclic dependency (since the interlink hash contains the genesis block hash).\r\n if (this.height === 1 && this._header.interlinkHash.equals(new Hash(null))) {\r\n return true;\r\n }\r\n\r\n // Check that the interlinkHash given in the header matches the actual interlinkHash.\r\n const interlinkHash = this._interlink.hash();\r\n if (!this._header.interlinkHash.equals(interlinkHash)) {\r\n Log.w(Block, 'Invalid block - interlink hash mismatch');\r\n return false;\r\n }\r\n\r\n // Everything checks out.\r\n return true;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n * @private\r\n */\r\n _verifyBody() {\r\n // Check that the body is valid.\r\n if (!this._body.verify()) {\r\n return false;\r\n }\r\n\r\n // Check that bodyHash given in the header matches the actual body hash.\r\n const bodyHash = this._body.hash();\r\n if (!this._header.bodyHash.equals(bodyHash)) {\r\n Log.w(Block, 'Invalid block - body hash mismatch');\r\n return false;\r\n }\r\n\r\n // Everything checks out.\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Block} predecessor\r\n * @returns {Promise.<boolean>}\r\n */\r\n async isImmediateSuccessorOf(predecessor) {\r\n // Check the header.\r\n if (!this._header.isImmediateSuccessorOf(predecessor.header)) {\r\n return false;\r\n }\r\n\r\n // Check that the interlink is correct.\r\n const interlink = await predecessor.getNextInterlink(this.target, this.version);\r\n if (!this._interlink.equals(interlink)) {\r\n return false;\r\n }\r\n\r\n // Everything checks out.\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Block} predecessor\r\n * @returns {Promise.<boolean>}\r\n */\r\n async isInterlinkSuccessorOf(predecessor) {\r\n // Check that the height is higher than the predecessor's.\r\n if (this._header.height <= predecessor.header.height) {\r\n Log.v(Block, 'No interlink successor - height');\r\n return false;\r\n }\r\n\r\n // Check that the timestamp is greater or equal to the predecessor's timestamp.\r\n if (this._header.timestamp < predecessor.header.timestamp) {\r\n Log.v(Block, 'No interlink successor - timestamp');\r\n return false;\r\n }\r\n\r\n // Check that the predecessor is contained in this block's interlink and verify its position.\r\n const prevHash = predecessor.hash();\r\n if (!GenesisConfig.GENESIS_HASH.equals(prevHash)) {\r\n const prevPow = await predecessor.pow();\r\n const targetHeight = BlockUtils.getTargetHeight(this.target);\r\n let blockFound = false;\r\n\r\n let depth = 0;\r\n for (; depth < this._interlink.length; depth++) {\r\n if (prevHash.equals(this._interlink.hashes[depth])) {\r\n blockFound = true;\r\n const target = new BigNumber(2).pow(targetHeight - depth);\r\n if (!BlockUtils.isProofOfWork(prevPow, target)) {\r\n Log.v(Block, 'No interlink successor - invalid position in interlink');\r\n return false;\r\n }\r\n }\r\n }\r\n\r\n if (!blockFound) {\r\n Log.v(Block, 'No interlink successor - not in interlink');\r\n return false;\r\n }\r\n }\r\n\r\n // If the predecessor happens to be the immediate predecessor, check additionally:\r\n // - that the height of the successor is one higher\r\n // - that the interlink is correct.\r\n if (this._header.prevHash.equals(prevHash)) {\r\n if (this._header.height !== predecessor.header.height + 1) {\r\n Log.v(Block, 'No interlink successor - immediate height');\r\n return false;\r\n }\r\n\r\n const interlink = await predecessor.getNextInterlink(this.target, this.version);\r\n const interlinkHash = interlink.hash();\r\n if (!this._header.interlinkHash.equals(interlinkHash)) {\r\n Log.v(Block, 'No interlink successor - immediate interlink');\r\n return false;\r\n }\r\n }\r\n // Otherwise, if the prevHash doesn't match but the blocks should be adjacent according to their height fields,\r\n // this cannot be a valid successor of predecessor.\r\n else if (this._header.height === predecessor.header.height + 1) {\r\n Log.v(Block, 'No interlink successor - immediate height (2)');\r\n return false;\r\n }\r\n // Otherwise, check that the interlink construction is valid given the information we have.\r\n else {\r\n // TODO Take different targets into account.\r\n\r\n // The number of new blocks in the interlink is bounded by the height difference.\r\n /** @type {HashSet.<Hash>} */\r\n const hashes = new HashSet();\r\n hashes.addAll(this._interlink.hashes);\r\n hashes.removeAll(predecessor.interlink.hashes);\r\n if (hashes.length > this._header.height - predecessor.header.height) {\r\n Log.v(Block, 'No interlink successor - too many new blocks');\r\n return false;\r\n }\r\n\r\n // Check that the interlink is not too short.\r\n const thisDepth = BlockUtils.getTargetDepth(this.target);\r\n const prevDepth = BlockUtils.getTargetDepth(predecessor.target);\r\n const depthDiff = thisDepth - prevDepth;\r\n if (this._interlink.length < predecessor.interlink.length - depthDiff) {\r\n Log.v(Block, 'No interlink successor - interlink too short');\r\n return false;\r\n }\r\n\r\n // If the same block is found in both interlinks, all blocks at lower depths must be the same in both interlinks.\r\n let commonBlock = false;\r\n const thisInterlink = this._interlink.hashes;\r\n const prevInterlink = predecessor.interlink.hashes;\r\n for (let i = 1; i < prevInterlink.length && i - depthDiff < thisInterlink.length; i++) {\r\n if (prevInterlink[i].equals(thisInterlink[i - depthDiff])) {\r\n commonBlock = true;\r\n } else if (commonBlock) {\r\n Log.v(Block, 'No interlink successor - invalid common suffix');\r\n return false;\r\n }\r\n }\r\n }\r\n\r\n // Everything checks out.\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Block} predecessor\r\n * @returns {Promise.<boolean>}\r\n */\r\n async isSuccessorOf(predecessor) {\r\n // TODO Improve this! Lots of duplicate checks.\r\n return (await this.isImmediateSuccessorOf(predecessor)) || (await this.isInterlinkSuccessorOf(predecessor));\r\n }\r\n\r\n /**\r\n * @param {BigNumber} nextTarget\r\n * @param {number} [nextVersion]\r\n * @returns {Promise.<BlockInterlink>}\r\n */\r\n async getNextInterlink(nextTarget, nextVersion = BlockHeader.CURRENT_VERSION) {\r\n /** @type {Array.<Hash>} */\r\n const hashes = [];\r\n const hash = this.hash();\r\n\r\n // Compute how many times this blockHash should be included in the next interlink.\r\n const thisPowDepth = BlockUtils.getHashDepth(await this.pow());\r\n const nextTargetDepth = BlockUtils.getTargetDepth(nextTarget);\r\n const numOccurrences = Math.max(thisPowDepth - nextTargetDepth + 1, 0);\r\n\r\n // Push this blockHash numOccurrences times onto the next interlink.\r\n for (let i = 0; i < numOccurrences; i++) {\r\n hashes.push(hash);\r\n }\r\n\r\n // Compute how many blocks to omit from the beginning of this interlink.\r\n const thisTargetDepth = BlockUtils.getTargetDepth(this.target);\r\n const targetOffset = nextTargetDepth - thisTargetDepth;\r\n const interlinkOffset = numOccurrences + targetOffset;\r\n\r\n // Push the remaining hashes from this interlink.\r\n for (let i = interlinkOffset; i < this.interlink.length; i++) {\r\n hashes.push(this.interlink.hashes[i]);\r\n }\r\n\r\n return new BlockInterlink(hashes, hash);\r\n }\r\n\r\n /**\r\n * @returns {Block}\r\n */\r\n shallowCopy() {\r\n return new Block(this._header, this._interlink, this._body);\r\n }\r\n\r\n /**\r\n * @param {Block|*} o\r\n * @returns {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof Block\r\n && this._header.equals(o._header)\r\n && this._interlink.equals(o._interlink)\r\n && (this._body ? this._body.equals(o._body) : !o._body);\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n isLight() {\r\n return !this._body;\r\n }\r\n\r\n /**\r\n * @returns {boolean}\r\n */\r\n isFull() {\r\n return !!this._body;\r\n }\r\n\r\n /**\r\n * @returns {Block}\r\n */\r\n toLight() {\r\n return this.isLight() ? this : new Block(this._header, this._interlink);\r\n }\r\n\r\n /**\r\n * @param {BlockBody} body\r\n * @returns {Block}\r\n */\r\n toFull(body) {\r\n return this.isFull() ? this : new Block(this._header, this._interlink, body);\r\n }\r\n\r\n /**\r\n * @type {BlockHeader}\r\n */\r\n get header() {\r\n return this._header;\r\n }\r\n\r\n /**\r\n * @type {BlockInterlink}\r\n */\r\n get interlink() {\r\n return this._interlink;\r\n }\r\n\r\n /**\r\n * @type {BlockBody}\r\n */\r\n get body() {\r\n if (this.isLight()) {\r\n throw new Error('Cannot access body of light block');\r\n }\r\n return this._body;\r\n }\r\n\r\n /**\r\n * @returns {number}\r\n */\r\n get version() {\r\n return this._header.version;\r\n }\r\n\r\n /**\r\n * @type {Hash}\r\n */\r\n get prevHash() {\r\n return this._header.prevHash;\r\n }\r\n\r\n /**\r\n * @type {Hash}\r\n */\r\n get interlinkHash() {\r\n return this._header.interlinkHash;\r\n }\r\n\r\n /**\r\n * @type {Hash}\r\n */\r\n get bodyHash() {\r\n return this._header.bodyHash;\r\n }\r\n\r\n /**\r\n * @type {Hash}\r\n */\r\n get accountsHash() {\r\n return this._header.accountsHash;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get nBits() {\r\n return this._header.nBits;\r\n }\r\n\r\n /**\r\n * @type {BigNumber}\r\n */\r\n get target() {\r\n return this._header.target;\r\n }\r\n\r\n /**\r\n * @type {BigNumber}\r\n */\r\n get difficulty() {\r\n return this._header.difficulty;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get height() {\r\n return this._header.height;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get timestamp() {\r\n return this._header.timestamp;\r\n }\r\n\r\n /**\r\n * @type {number}\r\n */\r\n get nonce() {\r\n return this._header.nonce;\r\n }\r\n\r\n /**\r\n * @type {Address}\r\n */\r\n get minerAddr() {\r\n return this._body ? this._body.minerAddr : undefined;\r\n }\r\n\r\n /**\r\n * @type {?Array.<Transaction>}\r\n */\r\n get transactions() {\r\n return this._body ? this._body.transactions : undefined;\r\n }\r\n\r\n /**\r\n * @returns {?Uint8Array}\r\n */\r\n get extraData() {\r\n return this._body ? this._body.extraData : undefined;\r\n }\r\n\r\n /**\r\n * @returns {?Array.<PrunedAccount>}\r\n */\r\n get prunedAccounts() {\r\n return this._body ? this._body.prunedAccounts : undefined;\r\n }\r\n\r\n /**\r\n * @type {?number}\r\n */\r\n get transactionCount() {\r\n return this._body ? this._body.transactionCount : undefined;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {Hash}\r\n */\r\n hash(buf) {\r\n return this._header.hash(buf);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @returns {Promise.<Hash>}\r\n */\r\n pow(buf) {\r\n return this._header.pow(buf);\r\n }\r\n\r\n /**\r\n * @param {Block|object|string} block\r\n */\r\n static fromAny(block) {\r\n if (block instanceof Block) return block;\r\n if (typeof block === 'object') return Block.fromPlain(block);\r\n if (typeof block === 'string') return Block.unserialize(BufferUtils.fromHex(block));\r\n throw new Error('Invalid block');\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n */\r\n static fromPlain(plain) {\r\n const header = new BlockHeader(\r\n Hash.fromAny(plain.prevHash),\r\n Hash.fromAny(plain.interlinkHash),\r\n Hash.fromAny(plain.bodyHash),\r\n Hash.fromAny(plain.accountsHash),\r\n plain.nBits,\r\n plain.height,\r\n plain.timestamp,\r\n plain.nonce,\r\n plain.version\r\n );\r\n const interlink = new BlockInterlink((plain.interlink.hashes || plain.interlink).map(h => Hash.fromAny(h)), Hash.fromAny(plain.prevHash));\r\n let body = null;\r\n if (plain.minerAddr && plain.extraData !== undefined && Array.isArray(plain.transactions) && Array.isArray(plain.prunedAccounts)) {\r\n body = new BlockBody(\r\n Address.fromAny(plain.minerAddr),\r\n plain.transactions.map(tx => Transaction.fromAny(tx)),\r\n BufferUtils.fromAny(plain.extraData),\r\n plain.prunedAccounts.map(pa => PrunedAccount.fromAny(pa))\r\n );\r\n }\r\n return new Block(header, interlink, body);\r\n }\r\n\r\n toString() {\r\n return `Block{height=${this.height},prev=${this.prevHash}}`;\r\n }\r\n\r\n toPlain() {\r\n const plain = {\r\n version: this.version,\r\n hash: this.hash().toPlain(),\r\n prevHash: this.prevHash.toPlain(),\r\n interlinkHash: this.interlinkHash.toPlain(),\r\n bodyHash: this.bodyHash.toPlain(),\r\n accountsHash: this.accountsHash.toPlain(),\r\n nBits: this.nBits,\r\n difficulty: this.difficulty.toString(),\r\n height: this.height,\r\n timestamp: this.timestamp,\r\n nonce: this.nonce,\r\n interlink: this.interlink.hashes.map(h => h.toPlain()),\r\n };\r\n if (this.isFull()) {\r\n plain.minerAddr = this.minerAddr.toPlain();\r\n plain.transactions = this.transactions.map(tx => tx.toPlain());\r\n plain.extraData = BufferUtils.toHex(this.extraData);\r\n plain.prunedAccounts = this.prunedAccounts.map(pa => pa.toPlain());\r\n }\r\n return plain;\r\n }\r\n}\r\n\r\nBlock.TIMESTAMP_DRIFT_MAX = 600 /* seconds */; // 10 minutes\r\nClass.register(Block);\r\n","/**\r\n * @abstract\r\n */\r\nclass Transaction {\r\n /**\r\n * @param {Transaction.Format} format\r\n * @param {Address} sender\r\n * @param {Account.Type} senderType\r\n * @param {Address} recipient\r\n * @param {Account.Type} recipientType\r\n * @param {BigNumber|number|string} value\r\n * @param {number} validityStartHeight\r\n * @param {Transaction.Flag | *} flags\r\n * @param {Uint8Array} data\r\n * @param {Uint8Array} [proof]\r\n * @param {number} [networkId]\r\n */\r\n constructor(format, sender, senderType, recipient, recipientType, value, validityStartHeight, flags, data, proof, networkId = GenesisConfig.NETWORK_ID) {\r\n const bigValue = new BigNumber(value);\r\n if (!(sender instanceof Address)) throw new Error('Malformed sender');\r\n if (!NumberUtils.isUint8(senderType)) throw new Error('Malformed sender type');\r\n if (!(recipient instanceof Address)) throw new Error('Malformed recipient');\r\n if (!NumberUtils.isUint8(recipientType)) throw new Error('Malformed recipient type');\r\n if (!NumberUtils.isUint128(bigValue) || bigValue.eq(0)) throw new Error('Malformed value');\r\n if (!NumberUtils.isUint32(validityStartHeight)) throw new Error('Malformed validityStartHeight');\r\n if (!NumberUtils.isUint8(flags) && (flags & ~(Transaction.Flag.ALL)) > 0) throw new Error('Malformed flags');\r\n if (!(data instanceof Uint8Array) || !(NumberUtils.isUint16(data.byteLength))) throw new Error('Malformed data');\r\n if (proof && (!(proof instanceof Uint8Array) || !(NumberUtils.isUint16(proof.byteLength)))) throw new Error('Malformed proof');\r\n if (!NumberUtils.isUint8(networkId)) throw new Error('Malformed networkId');\r\n\r\n /** @type {Transaction.Format} */\r\n this._format = format;\r\n /** @type {Address} */\r\n this._sender = sender;\r\n /** @type {Account.Type} */\r\n this._senderType = senderType;\r\n /** @type {Address} */\r\n this._recipient = recipient;\r\n /** @type {Account.Type} */\r\n this._recipientType = recipientType;\r\n /** @type {number} */\r\n this._value = bigValue;\r\n /** @type {number} */\r\n this._fee = Policy.txFee(validityStartHeight);\r\n /** @type {number} */\r\n this._networkId = networkId;\r\n /** @type {number} */\r\n this._validityStartHeight = validityStartHeight;\r\n /** @type {Transaction.Flag | *} */\r\n this._flags = flags;\r\n /** @type {Uint8Array} */\r\n this._data = data;\r\n /** @type {Uint8Array} */\r\n this._proof = proof;\r\n\r\n if (this._recipient === Address.CONTRACT_CREATION) this._recipient = this.getContractCreationAddress();\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Transaction}\r\n */\r\n static unserialize(buf) {\r\n const format = /** @type {Transaction.Format} */ buf.readUint8();\r\n buf.readPos--;\r\n\r\n if (!Transaction.FORMAT_MAP.has(format)) throw new Error('Invalid transaction type');\r\n return Transaction.FORMAT_MAP.get(format).unserialize(buf);\r\n }\r\n\r\n /**\r\n * @param {?SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serializeContent(buf) {\r\n buf = buf || new SerialBuffer(this.serializedContentSize);\r\n buf.writeUint16(this._data.byteLength);\r\n buf.write(this._data);\r\n this._sender.serialize(buf);\r\n buf.writeUint8(this._senderType);\r\n this._recipient.serialize(buf);\r\n buf.writeUint8(this._recipientType);\r\n buf.writeUint128(this._value);\r\n buf.writeUint128(this._fee);\r\n buf.writeUint32(this._validityStartHeight);\r\n buf.writeUint8(this._networkId);\r\n buf.writeUint8(this._flags);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedContentSize() {\r\n return /*dataSize*/ 2\r\n + this._data.byteLength\r\n + this._sender.serializedSize\r\n + /*senderType*/ 1\r\n + this._recipient.serializedSize\r\n + /*recipientType*/ 1\r\n + /*value*/ 16\r\n + /*fee*/ 16\r\n + /*validityStartHeight*/ 4\r\n + /*networkId*/ 1\r\n + /*flags*/ 1;\r\n }\r\n\r\n /**\r\n * @param {number} [networkId]\r\n * @returns {boolean}\r\n */\r\n verify(networkId) {\r\n if (this._valid === undefined) {\r\n this._valid = this._verify(networkId);\r\n }\r\n return this._valid;\r\n }\r\n\r\n /**\r\n * @param {number} [networkId]\r\n * @returns {boolean}\r\n * @private\r\n */\r\n _verify(networkId = GenesisConfig.NETWORK_ID) {\r\n if (this._networkId !== networkId) {\r\n Log.w(Transaction, 'Transaction is not valid in this network', this);\r\n return false;\r\n }\r\n // Check that sender != recipient.\r\n if (this._recipient.equals(this._sender)) {\r\n Log.w(Transaction, 'Sender and recipient must not match', this);\r\n return false;\r\n }\r\n if (!Account.TYPE_MAP.has(this._senderType) || !Account.TYPE_MAP.has(this._recipientType)) {\r\n Log.w(Transaction, 'Invalid account type', this);\r\n return false;\r\n }\r\n if (!Account.TYPE_MAP.get(this._senderType).verifyOutgoingTransaction(this)) {\r\n Log.w(Transaction, 'Invalid for sender', this);\r\n return false;\r\n }\r\n if (!Account.TYPE_MAP.get(this._recipientType).verifyIncomingTransaction(this)) {\r\n Log.w(Transaction, 'Invalid for recipient', this);\r\n return false;\r\n }\r\n if (!this._fee.eq(Policy.txFee(this._validityStartHeight))) {\r\n Log.w(Transaction, 'Invalid for tx fee', this);\r\n return false;\r\n }\r\n return true;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n throw new Error('Getter needs to be overwritten by subclasses');\r\n }\r\n\r\n /**\r\n * @param {?SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n throw new Error('Method needs to be overwritten by subclasses');\r\n }\r\n\r\n /**\r\n * @return {Hash}\r\n */\r\n hash() {\r\n // Exclude the signature, we don't want transactions to be malleable.\r\n this._hash = this._hash || Hash.light(this.serializeContent());\r\n return this._hash;\r\n }\r\n\r\n /**\r\n * @param {Transaction} o\r\n * @return {number}\r\n */\r\n compare(o) {\r\n if (this.fee.div(this.serializedSize).gt(o.fee.div(o.serializedSize))) return -1;\r\n if (this.fee.div(this.serializedSize).lt(o.fee.div(o.serializedSize))) return 1;\r\n if (this.serializedSize > o.serializedSize) return -1;\r\n if (this.serializedSize < o.serializedSize) return 1;\r\n if (this.fee.gt(o.fee)) return -1;\r\n if (this.fee.lt(o.fee)) return 1;\r\n if (this.value.gt(o.value)) return -1;\r\n if (this.value.lt(o.value)) return 1;\r\n return this.compareBlockOrder(o);\r\n }\r\n\r\n /**\r\n * @param {Transaction} o\r\n * @return {number}\r\n */\r\n compareBlockOrder(o) {\r\n // This function must return 0 iff this.equals(o).\r\n const recCompare = this._recipient.compare(o._recipient);\r\n if (recCompare !== 0) return recCompare;\r\n if (this._validityStartHeight < o._validityStartHeight) return -1;\r\n if (this._validityStartHeight > o._validityStartHeight) return 1;\r\n if (this._fee.gt(o._fee)) return -1;\r\n if (this._fee.lt(o._fee)) return 1;\r\n if (this._value.gt(o._value)) return -1;\r\n if (this._value.lt(o._value)) return 1;\r\n const senderCompare = this._sender.compare(o._sender);\r\n if (senderCompare !== 0) return senderCompare;\r\n if (this._recipientType < o._recipientType) return -1;\r\n if (this._recipientType > o._recipientType) return 1;\r\n if (this._senderType < o._senderType) return -1;\r\n if (this._senderType > o._senderType) return 1;\r\n if (this._flags < o._flags) return -1;\r\n if (this._flags > o._flags) return 1;\r\n return BufferUtils.compare(this._data, o._data);\r\n }\r\n\r\n /**\r\n * @param {Transaction} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n // This ignores format and proof to be consistent with hash():\r\n // tx1.hash() == tx2.hash() iff tx1.equals(t2)\r\n return o instanceof Transaction\r\n && this._sender.equals(o._sender)\r\n && this._senderType === o._senderType\r\n && this._recipient.equals(o._recipient)\r\n && this._recipientType === o._recipientType\r\n && this._value.eq(o._value)\r\n && this._fee.eq(o._fee)\r\n && this._validityStartHeight === o._validityStartHeight\r\n && this._networkId === o._networkId\r\n && this._flags === o._flags\r\n && BufferUtils.equals(this._data, o._data);\r\n }\r\n\r\n /**\r\n * @return {string}\r\n */\r\n toString() {\r\n return `Transaction{`\r\n + `sender=${this._sender.toHex()}, `\r\n + `recipient=${this._recipient.toHex()}, `\r\n + `value=${this._value.toString()}, `\r\n + `fee=${this._fee.toString()}, `\r\n + `validityStartHeight=${this._validityStartHeight}, `\r\n + `networkId=${this._networkId}`\r\n + `}`;\r\n }\r\n\r\n toPlain() {\r\n const data = Account.TYPE_MAP.get(this.recipientType).dataToPlain(this.data);\r\n data.raw = BufferUtils.toHex(this.data);\r\n const proof = Account.TYPE_MAP.get(this.senderType).proofToPlain(this.proof);\r\n proof.raw = BufferUtils.toHex(this.proof);\r\n return {\r\n transactionHash: this.hash().toPlain(),\r\n format: Transaction.Format.toString(this._format),\r\n sender: this.sender.toPlain(),\r\n senderType: Account.Type.toString(this.senderType),\r\n recipient: this.recipient.toPlain(),\r\n recipientType: Account.Type.toString(this.recipientType),\r\n value: this.value.toString(),\r\n fee: this.fee.toString(),\r\n feePerByte: this.feePerByte.toString(),\r\n validityStartHeight: this.validityStartHeight,\r\n network: GenesisConfig.networkIdToNetworkName(this.networkId),\r\n flags: this.flags,\r\n data,\r\n proof,\r\n size: this.serializedSize,\r\n valid: this.verify()\r\n };\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n * @return {Transaction}\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid transaction format');\r\n const format = Transaction.Format.fromAny(plain.format);\r\n if (!Transaction.FORMAT_MAP.has(format)) throw new Error('Invalid transaction type');\r\n return Transaction.FORMAT_MAP.get(format).fromPlain(plain);\r\n }\r\n\r\n /**\r\n * @param {Transaction|string|object} tx\r\n * @returns {Transaction}\r\n */\r\n static fromAny(tx) {\r\n if (tx instanceof Transaction) return tx;\r\n if (typeof tx === 'object') return Transaction.fromPlain(tx);\r\n if (typeof tx === 'string') return Transaction.unserialize(new SerialBuffer(BufferUtils.fromHex(tx)));\r\n throw new Error('Invalid transaction format');\r\n }\r\n\r\n /**\r\n * @return {Address}\r\n */\r\n getContractCreationAddress() {\r\n const tx = Transaction.unserialize(this.serialize());\r\n tx._recipient = Address.NULL;\r\n tx._hash = null;\r\n return Address.fromHash(tx.hash());\r\n }\r\n\r\n /** @type {Transaction.Format} */\r\n get format() {\r\n return this._format;\r\n }\r\n\r\n /** @type {Address} */\r\n get sender() {\r\n return this._sender;\r\n }\r\n\r\n /** @type {Account.Type} */\r\n get senderType() {\r\n return this._senderType;\r\n }\r\n\r\n /** @type {Address} */\r\n get recipient() {\r\n return this._recipient;\r\n }\r\n\r\n /** @type {Account.Type} */\r\n get recipientType() {\r\n return this._recipientType;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get value() {\r\n return this._value;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get fee() {\r\n return this._fee;\r\n }\r\n\r\n /** @type {BigNumber} */\r\n get feePerByte() {\r\n return this._fee.div(this.serializedSize);\r\n }\r\n\r\n /** @type {number} */\r\n get networkId() {\r\n return this._networkId;\r\n }\r\n\r\n /** @type {number} */\r\n get validityStartHeight() {\r\n return this._validityStartHeight;\r\n }\r\n\r\n /** @type {number} */\r\n get flags() {\r\n return this._flags;\r\n }\r\n\r\n /**\r\n * @param {Transaction.Flag} flag\r\n * @returns {boolean}\r\n */\r\n hasFlag(flag) {\r\n return (this._flags & flag) > 0;\r\n }\r\n\r\n /** @type {Uint8Array} */\r\n get data() {\r\n return this._data;\r\n }\r\n\r\n /** @type {Uint8Array} */\r\n get proof() {\r\n return this._proof;\r\n }\r\n\r\n // Sender proof is set by the Wallet after signing a transaction.\r\n /** @type {Uint8Array} */\r\n set proof(proof) {\r\n this._proof = proof;\r\n }\r\n}\r\n\r\n/**\r\n * Enum for Transaction formats.\r\n * @enum\r\n */\r\nTransaction.Format = {\r\n BASIC: 0,\r\n EXTENDED: 1\r\n};\r\n/**\r\n * @param {Transaction.Format} format\r\n */\r\nTransaction.Format.toString = function(format) {\r\n switch (format) {\r\n case Transaction.Format.BASIC: return 'basic';\r\n case Transaction.Format.EXTENDED: return 'extended';\r\n }\r\n throw new Error('Invalid transaction format');\r\n};\r\n/**\r\n * @param {Transaction.Format|string} format\r\n * @return {Transaction.Format}\r\n */\r\nTransaction.Format.fromAny = function(format) {\r\n if (typeof format === 'number') return format;\r\n switch (format) {\r\n case 'basic': return Transaction.Format.BASIC;\r\n case 'extended': return Transaction.Format.EXTENDED;\r\n }\r\n throw new Error('Invalid transaction format');\r\n};\r\n/**\r\n * @enum\r\n */\r\nTransaction.Flag = {\r\n NONE: 0,\r\n CONTRACT_CREATION: 0b1,\r\n ALL: 0b1\r\n};\r\n/** @type {Map.<Transaction.Format, {unserialize: function(buf: SerialBuffer):Transaction, fromPlain: function(plain:object):Transaction}>} */\r\nTransaction.FORMAT_MAP = new Map();\r\n\r\nClass.register(Transaction);\r\n","class SignatureProof {\r\n /**\r\n * @param {Transaction} transaction\r\n * @returns {boolean}\r\n */\r\n static verifyTransaction(transaction) {\r\n try {\r\n const buffer = new SerialBuffer(transaction.proof);\r\n const proof = SignatureProof.unserialize(buffer);\r\n\r\n // Reject proof if it is longer than needed.\r\n if (buffer.readPos !== buffer.byteLength) {\r\n Log.w(SignatureProof, 'Invalid SignatureProof - overlong');\r\n return false;\r\n }\r\n\r\n return proof.verify(transaction.sender, transaction.serializeContent());\r\n } catch (e) {\r\n Log.w(SignatureProof, `Failed to verify transaction: ${e.message || e}`);\r\n return false;\r\n }\r\n }\r\n\r\n /**\r\n * @param {PublicKey} publicKey\r\n * @param {Signature} signature\r\n * @returns {SignatureProof}\r\n */\r\n static singleSig(publicKey, signature) {\r\n return new SignatureProof(publicKey, new MerklePath([]), signature);\r\n }\r\n\r\n /**\r\n * @param {PublicKey} signerKey\r\n * @param {Array.<PublicKey>} publicKeys\r\n * @param {Signature} signature\r\n * @returns {SignatureProof}\r\n */\r\n static multiSig(signerKey, publicKeys, signature) {\r\n const merklePath = MerklePath.compute(publicKeys, signerKey);\r\n return new SignatureProof(signerKey, merklePath, signature);\r\n }\r\n\r\n /**\r\n * @param {PublicKey} publicKey\r\n * @param {MerklePath} merklePath\r\n * @param {Signature} signature\r\n */\r\n constructor(publicKey, merklePath, signature) {\r\n if (!(publicKey instanceof PublicKey)) throw new Error('Malformed publickKey');\r\n if (!(merklePath instanceof MerklePath)) throw new Error('Malformed merklePath');\r\n if (signature && !(signature instanceof Signature)) throw new Error('Malformed signature');\r\n\r\n /**\r\n * @type {PublicKey}\r\n * @private\r\n */\r\n this._publicKey = publicKey;\r\n /**\r\n * @type {MerklePath}\r\n * @private\r\n */\r\n this._merklePath = merklePath;\r\n /**\r\n * @type {Signature}\r\n * @private\r\n */\r\n this._signature = signature;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {SignatureProof}\r\n */\r\n static unserialize(buf) {\r\n const publicKey = PublicKey.unserialize(buf);\r\n const merklePath = MerklePath.unserialize(buf);\r\n const signature = Signature.unserialize(buf);\r\n return new SignatureProof(publicKey, merklePath, signature);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n this._publicKey.serialize(buf);\r\n this._merklePath.serialize(buf);\r\n\r\n // The SignatureProof is sometimes serialized before the signature is set (e.g. when creating transactions).\r\n // Simply don't serialize the signature if it's missing as this should never go over the wire.\r\n // We always expect the signature to be present when unserializing.\r\n if (this._signature) {\r\n this._signature.serialize(buf);\r\n }\r\n\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return this._publicKey.serializedSize\r\n + this._merklePath.serializedSize\r\n + (this._signature ? this._signature.serializedSize : 0);\r\n }\r\n \r\n static get SINGLE_SIG_SIZE() {\r\n return PublicKey.SIZE + new MerklePath([]).serializedSize + Signature.SIZE;\r\n }\r\n\r\n /**\r\n * @param {SignatureProof} o\r\n * @return {boolean}\r\n */\r\n equals(o) {\r\n return o instanceof SignatureProof\r\n && this._publicKey.equals(o._publicKey)\r\n && this._merklePath.equals(o._merklePath)\r\n && (this._signature ? this._signature.equals(o._signature) : this._signature === o._signature);\r\n }\r\n\r\n /**\r\n * @param {?Address} sender\r\n * @param {Uint8Array} data\r\n * @returns {boolean}\r\n */\r\n verify(sender, data) {\r\n if (sender !== null && !this.isSignedBy(sender)) {\r\n Log.w(SignatureProof, 'Invalid SignatureProof - signer does not match sender address');\r\n return false;\r\n }\r\n\r\n if (!this._signature) {\r\n Log.w(SignatureProof, 'Invalid SignatureProof - signature is missing');\r\n return false;\r\n }\r\n\r\n if (!this._signature.verify(this._publicKey, data)) {\r\n Log.w(SignatureProof, 'Invalid SignatureProof - signature is invalid');\r\n return false;\r\n }\r\n\r\n return true;\r\n }\r\n\r\n /**\r\n * @param {Address} sender\r\n * @returns {boolean}\r\n */\r\n isSignedBy(sender) {\r\n const merkleRoot = this._merklePath.computeRoot(this._publicKey);\r\n const signerAddr = Address.fromHash(merkleRoot);\r\n return signerAddr.equals(sender);\r\n }\r\n\r\n /** @type {PublicKey} */\r\n get publicKey() {\r\n return this._publicKey;\r\n }\r\n\r\n /** @type {MerklePath} */\r\n get merklePath() {\r\n return this._merklePath;\r\n }\r\n\r\n /** @type {Signature} */\r\n get signature() {\r\n return this._signature;\r\n }\r\n\r\n /** @type {Signature} */\r\n set signature(signature) {\r\n this._signature = signature;\r\n }\r\n}\r\n\r\nClass.register(SignatureProof);\r\n","class BasicTransaction extends Transaction {\r\n /**\r\n * @param {PublicKey} senderPubKey\r\n * @param {Address} recipient\r\n * @param {BigNumber|number|string} value\r\n * @param {number} validityStartHeight\r\n * @param {Signature} [signature]\r\n * @param {number} [networkId]\r\n */\r\n constructor(senderPubKey, recipient, value, validityStartHeight, signature, networkId) {\r\n if (!(senderPubKey instanceof PublicKey)) throw new Error('Malformed senderPubKey');\r\n // Signature may be initially empty and can be set later.\r\n if (signature !== undefined && !(signature instanceof Signature)) throw new Error('Malformed signature');\r\n\r\n const proof = SignatureProof.singleSig(senderPubKey, signature);\r\n super(Transaction.Format.BASIC, senderPubKey.toAddress(), Account.Type.BASIC, recipient, Account.Type.BASIC, value, validityStartHeight, Transaction.Flag.NONE, new Uint8Array(0), proof.serialize(), networkId);\r\n\r\n /**\r\n * @type {SignatureProof}\r\n * @private\r\n */\r\n this._signatureProof = proof;\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Transaction}\r\n */\r\n static unserialize(buf) {\r\n const type = buf.readUint8();\r\n Assert.that(type === Transaction.Format.BASIC);\r\n\r\n const senderPubKey = PublicKey.unserialize(buf);\r\n const recipient = Address.unserialize(buf);\r\n const value = buf.readUint128();\r\n const fee = buf.readUint128();\r\n const validityStartHeight = buf.readUint32();\r\n const networkId = buf.readUint8();\r\n const signature = Signature.unserialize(buf);\r\n return new BasicTransaction(senderPubKey, recipient, value, validityStartHeight, signature, networkId);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n * @return {BasicTransaction}\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid transaction format');\r\n return new BasicTransaction(\r\n PublicKey.fromAny(plain.proof.publicKey || plain.senderPubKey),\r\n Address.fromAny(plain.recipient),\r\n plain.value,\r\n plain.validityStartHeight,\r\n Signature.fromAny(plain.proof.signature || plain.signature),\r\n GenesisConfig.networkIdFromAny(plain.network || plain.networkId)\r\n );\r\n }\r\n\r\n /**\r\n * @param {?SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(Transaction.Format.BASIC);\r\n this.senderPubKey.serialize(buf);\r\n this._recipient.serialize(buf);\r\n buf.writeUint128(this._value);\r\n buf.writeUint128(this._fee);\r\n buf.writeUint32(this._validityStartHeight);\r\n buf.writeUint8(this._networkId);\r\n this.signature.serialize(buf);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return /*type*/ 1\r\n + this.senderPubKey.serializedSize\r\n + this._recipient.serializedSize\r\n + /*value*/ 16\r\n + /*fee*/ 16\r\n + /*validityStartHeight*/ 4\r\n + /*networkId*/ 1\r\n + this.signature.serializedSize;\r\n }\r\n\r\n /**\r\n * @type {PublicKey}\r\n */\r\n get senderPubKey() {\r\n return this._signatureProof.publicKey;\r\n }\r\n\r\n /**\r\n * @type {Signature}\r\n */\r\n get signature() {\r\n return this._signatureProof.signature;\r\n }\r\n\r\n /**\r\n * @type {Signature}\r\n */\r\n set signature(signature) {\r\n this._signatureProof.signature = signature;\r\n this._proof = this._signatureProof.serialize();\r\n }\r\n}\r\nTransaction.FORMAT_MAP.set(Transaction.Format.BASIC, BasicTransaction);\r\nClass.register(BasicTransaction);\r\n","class ExtendedTransaction extends Transaction {\r\n\r\n /**\r\n * @param {Address} sender\r\n * @param {Account.Type} senderType\r\n * @param {Address} recipient\r\n * @param {Account.Type} recipientType\r\n * @param {BigNumber|number|string} value\r\n * @param {number} validityStartHeight\r\n * @param {Transaction.Flag | *} flags\r\n * @param {Uint8Array} data\r\n * @param {Uint8Array} [proof]\r\n * @param {number} [networkId]\r\n */\r\n constructor(sender, senderType, recipient, recipientType, value, validityStartHeight, flags, data, proof = new Uint8Array(0), networkId) {\r\n super(Transaction.Format.EXTENDED, sender, senderType, recipient, recipientType, value, validityStartHeight, flags, data, proof, networkId);\r\n }\r\n\r\n /**\r\n * @param {SerialBuffer} buf\r\n * @return {Transaction}\r\n */\r\n static unserialize(buf) {\r\n const type = /** @type {Transaction.Format} */ buf.readUint8();\r\n Assert.that(type === Transaction.Format.EXTENDED);\r\n\r\n const dataSize = buf.readUint16();\r\n const data = buf.read(dataSize);\r\n const sender = Address.unserialize(buf);\r\n const senderType = /** @type {Account.Type} */ buf.readUint8();\r\n const recipient = Address.unserialize(buf);\r\n const recipientType = /** @type {Account.Type} */ buf.readUint8();\r\n const value = buf.readUint128();\r\n const fee = buf.readUint128();\r\n const validityStartHeight = buf.readUint32();\r\n const networkId = buf.readUint8();\r\n const flags = buf.readUint8();\r\n const proofSize = buf.readUint16();\r\n const proof = buf.read(proofSize);\r\n return new ExtendedTransaction(sender, senderType, recipient, recipientType, value, validityStartHeight, flags, data, proof, networkId);\r\n }\r\n\r\n /**\r\n * @param {object} plain\r\n * @return {ExtendedTransaction}\r\n */\r\n static fromPlain(plain) {\r\n if (!plain) throw new Error('Invalid transaction format');\r\n return new ExtendedTransaction(\r\n Address.fromAny(plain.sender),\r\n Account.Type.fromAny(plain.senderType),\r\n Address.fromAny(plain.recipient),\r\n Account.Type.fromAny(plain.recipientType),\r\n plain.value,\r\n plain.validityStartHeight,\r\n plain.flags,\r\n BufferUtils.fromAny(plain.data.raw === undefined ? plain.data : plain.data.raw),\r\n BufferUtils.fromAny(plain.proof.raw === undefined ? plain.proof : plain.proof.raw),\r\n GenesisConfig.networkIdFromAny(plain.network || plain.networkId)\r\n );\r\n }\r\n\r\n /**\r\n * @param {?SerialBuffer} [buf]\r\n * @return {SerialBuffer}\r\n */\r\n serialize(buf) {\r\n buf = buf || new SerialBuffer(this.serializedSize);\r\n buf.writeUint8(Transaction.Format.EXTENDED);\r\n this.serializeContent(buf);\r\n buf.writeUint16(this._proof.byteLength);\r\n buf.write(this._proof);\r\n return buf;\r\n }\r\n\r\n /** @type {number} */\r\n get serializedSize() {\r\n return /*type*/ 1\r\n + this.serializedContentSize\r\n + /*proofSize*/ 2\r\n + this._proof.byteLength;\r\n }\r\n}\r\n\r\nTransaction.FORMAT_MAP.set(Transaction.Format.EXTENDED, ExtendedTransaction);\r\nClass.register(ExtendedTransaction);\r\n"]}