{"version":3,"sources":["webpack://EVM/webpack/universalModuleDefinition","webpack://EVM/webpack/bootstrap","webpack://EVM/./src/utils/stringify.ts","webpack://EVM/./node_modules/big-integer/BigInteger.js","webpack://EVM/./src/opcodes/mload.ts","webpack://EVM/./src/opcodes/mod.ts","webpack://EVM/./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack://EVM/./src/opcodes/add.ts","webpack://EVM/./src/opcodes/mul.ts","webpack://EVM/./src/opcodes/sub.ts","webpack://EVM/./src/opcodes/shl.ts","webpack://EVM/./src/opcodes/sar.ts","webpack://EVM/./src/opcodes/lt.ts","webpack://EVM/./src/opcodes/gt.ts","webpack://EVM/./src/opcodes/jumpi.ts","webpack://EVM/./src/utils/stringifyInstructions.ts","webpack://EVM/./src/index.ts","webpack://EVM/./src/classes/tx.class.ts","webpack://EVM/(webpack)/buildin/global.js","webpack://EVM/./node_modules/base64-js/index.js","webpack://EVM/./node_modules/ieee754/index.js","webpack://EVM/./node_modules/node-libs-browser/node_modules/isarray/index.js","webpack://EVM/(webpack)/buildin/module.js","webpack://EVM/./src/classes/evm.class.ts","webpack://EVM/./node_modules/ethereumjs-vm/dist/opcodes.js","webpack://EVM/./src/utils/opcodes.ts","webpack://EVM/./src/opcodes/stop.ts","webpack://EVM/./src/opcodes/div.ts","webpack://EVM/./src/opcodes/addmod.ts","webpack://EVM/./src/opcodes/mulmod.ts","webpack://EVM/./src/opcodes/exp.ts","webpack://EVM/./src/opcodes/signextend.ts","webpack://EVM/./src/opcodes/eq.ts","webpack://EVM/./src/opcodes/iszero.ts","webpack://EVM/./src/opcodes/and.ts","webpack://EVM/./src/opcodes/or.ts","webpack://EVM/./src/opcodes/xor.ts","webpack://EVM/./src/opcodes/not.ts","webpack://EVM/./src/opcodes/byte.ts","webpack://EVM/./src/opcodes/shr.ts","webpack://EVM/./src/opcodes/sha3.ts","webpack://EVM/./src/opcodes/address.ts","webpack://EVM/./src/opcodes/balance.ts","webpack://EVM/./src/opcodes/origin.ts","webpack://EVM/./src/opcodes/caller.ts","webpack://EVM/./src/opcodes/callvalue.ts","webpack://EVM/./src/opcodes/calldataload.ts","webpack://EVM/./src/opcodes/calldatasize.ts","webpack://EVM/./src/opcodes/calldatacopy.ts","webpack://EVM/./src/opcodes/codesize.ts","webpack://EVM/./src/opcodes/codecopy.ts","webpack://EVM/./src/opcodes/gasprice.ts","webpack://EVM/./src/opcodes/extcodesize.ts","webpack://EVM/./src/opcodes/extcodecopy.ts","webpack://EVM/./src/opcodes/returndatasize.ts","webpack://EVM/./src/opcodes/returndatacopy.ts","webpack://EVM/./src/opcodes/extcodehash.ts","webpack://EVM/./src/opcodes/blockhash.ts","webpack://EVM/./src/opcodes/coinbase.ts","webpack://EVM/./src/opcodes/timestamp.ts","webpack://EVM/./src/opcodes/number.ts","webpack://EVM/./src/opcodes/difficulty.ts","webpack://EVM/./src/opcodes/gaslimit.ts","webpack://EVM/./src/opcodes/pop.ts","webpack://EVM/./src/opcodes/mstore.ts","webpack://EVM/./src/opcodes/sload.ts","webpack://EVM/./src/opcodes/sstore.ts","webpack://EVM/./src/opcodes/jump.ts","webpack://EVM/./src/opcodes/pc.ts","webpack://EVM/./src/opcodes/msize.ts","webpack://EVM/./src/opcodes/gas.ts","webpack://EVM/./src/opcodes/jumpdest.ts","webpack://EVM/./src/opcodes/push.ts","webpack://EVM/./src/opcodes/dup.ts","webpack://EVM/./src/opcodes/swap.ts","webpack://EVM/./src/opcodes/log.ts","webpack://EVM/./src/opcodes/create.ts","webpack://EVM/./src/opcodes/call.ts","webpack://EVM/./src/opcodes/callcode.ts","webpack://EVM/./src/opcodes/return.ts","webpack://EVM/./src/utils/hex.ts","webpack://EVM/./src/opcodes/delegatecall.ts","webpack://EVM/./src/opcodes/create2.ts","webpack://EVM/./src/opcodes/staticcall.ts","webpack://EVM/./src/opcodes/revert.ts","webpack://EVM/./src/opcodes/invalid.ts","webpack://EVM/./src/opcodes/selfdestruct.ts","webpack://EVM/./src/utils/stringifyEvents.ts","webpack://EVM/./src/utils/stringifyStructs.ts","webpack://EVM/./src/utils/stringifyMappings.ts","webpack://EVM/./src/utils/stringifyVariables.ts","webpack://EVM/./src/utils/stringifyFunctions.ts","webpack://EVM/./src/classes/stack.class.ts"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","BigNumber","default","item","isInstance","toString","wrapped","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","bigInt","undefined","BASE","LOG_BASE","MAX_INT","MAX_INT_ARR","smallToArray","DEFAULT_ALPHABET","supportsNativeBigInt","BigInt","pow","Integer","v","radix","alphabet","caseSensitive","parseBase","parseValue","BigInteger","sign","this","isSmall","SmallInteger","NativeBigInt","isPrecise","Math","floor","arrayToSmall","arr","trim","length","compareAbs","createArray","x","Array","truncate","ceil","add","a","b","sum","l_a","l_b","carry","base","push","addAny","addSmall","subtract","difference","a_l","b_l","borrow","subtractAny","subtractSmall","multiplyLong","product","a_i","j","multiplySmall","shiftLeft","concat","multiplyKaratsuba","y","max","slice","ac","bd","abcd","useKaratsuba","l1","l2","multiplySmallAndArray","square","divMod1","quotientDigit","shift","q","result","divisorMostSignificantDigit","lambda","remainder","divisor","divModSmall","divMod2","guess","xlen","highx","highy","check","part","unshift","reverse","quotient","divModAny","self","Error","negate","abs","comparison","qSign","mod","mSign","isBasicPrime","isUnit","equals","isEven","isDivisibleBy","lesser","millerRabinTest","nPrev","prev","divide","next","modPow","plus","minus","small","multiply","times","_multiplyBySmall","divmod","over","eval","isNegative","exp","isZero","isPositive","isOdd","compare","Infinity","compareTo","eq","notEquals","neq","greater","gt","lt","greaterOrEquals","geq","lesserOrEquals","leq","isPrime","strict","bits","bitLength","logN","log","toJSNumber","isProbablePrime","iterations","randBetween","modInv","lastT","lastR","zero","newT","one","newR","powersOfTwo","powers2Length","highestPower2","shift_isSmall","bitwise","fn","xSign","ySign","xRem","not","yRem","xDigit","yDigit","xDivMod","yDivMod","String","shiftRight","remQuo","and","or","xor","LOBMASK_I","LOBMASK_BI","roughLOB","integerLogarithm","tmp","e","min","gcd","lcm","low","range","random","digits","toBase","restricted","top","digit","fromArray","text","toLowerCase","absBase","alphabetValues","start","parseBaseFromArray","val","stringify","apply","map","valueOf","neg","Number","out","left","toBaseString","join","parseStringValue","split","decimalPlace","indexOf","test","parseNumberValue","toArray","str","toJSON","parseInt","minusOne","stringify_1","MLOAD","[object Object]","location","opcode","state","memoryLocation","stack","pop","memory","MOD","right","global","base64","ieee754","isArray","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","__proto__","arg","encodingOrOffset","allocUnsafe","from","TypeError","ArrayBuffer","array","byteOffset","byteLength","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","write","fromString","obj","isBuffer","len","checked","copy","buffer","type","data","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","swap","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","read","buf","readUInt16BE","foundIndex","found","hexWrite","offset","remaining","strLen","parsed","substr","utf8Write","blitBuffer","asciiWrite","byteArray","charCodeAt","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","base64Slice","end","fromByteArray","utf8Slice","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","foo","subarray","typedArraySupport","poolSize","_augment","species","configurable","fill","allocUnsafeSlow","_isBuffer","list","pos","swap16","swap32","swap64","arguments","hexSlice","asciiSlice","latin1Slice","utf16leSlice","inspect","match","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","_arr","ret","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","code","INVALID_BASE64_RE","leadSurrogate","toByteArray","replace","stringtrim","base64clean","src","dst","ADD","MUL","SUB","SHL","SAR","LT","equal","GT","functionHashes","updateCallDataLoad","types","argNumber","findReturns","returns","items","deepReturns","TopLevelFunction","hash","gasUsed","payable","visibility","constant","REQUIRE","condition","functionName","argumentTypes","forEach","every","returnItem","Variable","label","JUMPI","ifTrue","ifFalse","skipped","valid","true","false","jumpLocation","jumpCondition","opcodes","getOpcodes","jumpLocationData","find","pc","jumpIndex","jumps","instructions","halted","trueClone","clone","trueCloneTree","parse","falseClone","falseCloneTree","functions","functionClone","functionCloneTree","fullFunction","mappings","structlocation","structs","variables","stringifyInstructions","instructionTree","indentation","instructionLines","instruction","falseInstructions","filter","debugLevel","repeat","elseOrElseIf","startsWith","_functions","_events","_functionHashes","_eventHashes","tx_class_1","Transaction","evm_class_1","EVM","events","eventHashes","parseSingle","substring","transactionObject","blockHash","blockNumber","gas","gasPrice","input","to","functionHash","getFunctionHash","rawFunction","getFunction","descriptive","functionArguments","getRawArguments","rawFunctionArguments","functionArgumentType","functionArgument","g","Function","b64","lens","getLens","validLen","placeHoldersLen","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","len2","encodeChunk","lookup","num","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","LN2","webpackPolyfill","deprecate","paths","children","findOpcode","opcodes_1","stringifyEvents_1","stringifyStructs_1","stringifyMappings_1","stringifyVariables_1","stringifyFunctions_1","stringifyInstructions_1","stack_class_1","storage","layer","assign","index","currentOp","pushDataLength","pushData","Set","fee","reduce","getBytecode","reset","getEvents","keys","codes","0","1","2","3","4","5","6","7","8","9","10","11","16","17","18","19","20","21","22","23","24","25","26","27","28","29","32","48","49","50","51","52","53","54","55","56","57","58","59","60","61","62","63","64","65","66","67","68","69","80","81","82","83","84","85","86","87","88","89","90","91","96","97","98","99","100","101","102","103","104","105","106","107","108","109","110","111","112","113","114","115","116","117","118","119","120","121","122","123","124","125","126","127","128","129","130","131","132","133","134","135","136","137","138","139","140","141","142","143","144","145","146","147","148","149","150","151","152","153","154","155","156","157","158","159","160","161","162","163","164","240","241","242","243","244","245","250","253","254","255","op","full","freeLogs","in","dynamic","async","stop_1","add_1","mul_1","sub_1","div_1","mod_1","addmod_1","mulmod_1","exp_1","signextend_1","lt_1","gt_1","eq_1","iszero_1","and_1","or_1","xor_1","not_1","byte_1","shl_1","shr_1","sar_1","sha3_1","address_1","balance_1","origin_1","caller_1","callvalue_1","calldataload_1","calldatasize_1","calldatacopy_1","codesize_1","codecopy_1","gasprice_1","extcodesize_1","extcodecopy_1","returndatasize_1","returndatacopy_1","extcodehash_1","blockhash_1","coinbase_1","timestamp_1","number_1","difficulty_1","gaslimit_1","pop_1","mload_1","mstore_1","sload_1","sstore_1","jump_1","jumpi_1","pc_1","msize_1","gas_1","jumpdest_1","push_1","dup_1","swap_1","log_1","create_1","call_1","callcode_1","return_1","delegatecall_1","create2_1","staticcall_1","revert_1","invalid_1","selfdestruct_1","STOP","DIV","SDIV","SMOD","ADDMOD","MULMOD","EXP","SIGNEXTEND","SLT","SGT","EQ","ISZERO","AND","OR","XOR","NOT","BYTE","SHR","SHA3","ADDRESS","BALANCE","ORIGIN","CALLER","CALLVALUE","CALLDATALOAD","CALLDATASIZE","CALLDATACOPY","CODESIZE","CODECOPY","GASPRICE","EXTCODESIZE","EXTCODECOPY","RETURNDATASIZE","RETURNDATACOPY","EXTCODEHASH","BLOCKHASH","COINBASE","TIMESTAMP","NUMBER","DIFFICULTY","GASLIMIT","POP","MSTORE","MSTORE8","SLOAD","SSTORE","JUMP","PC","MSIZE","GAS","JUMPDEST","PUSH1","PUSH2","PUSH3","PUSH4","PUSH5","PUSH6","PUSH7","PUSH8","PUSH9","PUSH10","PUSH11","PUSH12","PUSH13","PUSH14","PUSH15","PUSH16","PUSH17","PUSH18","PUSH19","PUSH20","PUSH21","PUSH22","PUSH23","PUSH24","PUSH25","PUSH26","PUSH27","PUSH28","PUSH29","PUSH30","PUSH31","PUSH32","DUP1","DUP2","DUP3","DUP4","DUP5","DUP6","DUP7","DUP8","DUP9","DUP10","DUP11","DUP12","DUP13","DUP14","DUP15","DUP16","SWAP1","SWAP2","SWAP3","SWAP4","SWAP5","SWAP6","SWAP7","SWAP8","SWAP9","SWAP10","SWAP11","SWAP12","SWAP13","SWAP14","SWAP15","SWAP16","LOG0","LOG1","LOG2","LOG3","LOG4","CREATE","CALL","CALLCODE","RETURN","DELEGATECALL","CREATE2","STATICCALL","REVERT","INVALID","SELFDESTRUCT","SIG","position","memoryStart","memoryLength","address","startLocation","copyLength","returnDataPosition","returnDataSize","memoryPosition","number","storeLocation","storeData","parseMapping","item2","MappingLoad","count","mappingName","mappingItems","mappingLocation","mappingItem","mappingParts","values","MappingStore","variableName","bad","duplicateLocation","duplicate","swapLocation","LOG","topics","eventName","topicsCount","eventTopic","indexedCount","anonymous","outputStart","outputLength","hex_1","static","hex2a","hexx","hex","isHex","h","pad32","pieces","stringLength","stateEvents","stateEventValues","event","eventArguments","stateEvent","mapping","struct","stringifyMapping","mappingKey","mappingValue","deepMapping","mappingChild","mappingChild2","variable","functionInstance","fullFunctionName","fullFunctionArguments","Stack","elements","secondPosition","firstValue","secondValue"],"mappings":"CAAA,SAAAA,EAAAC,GACA,iBAAAC,SAAA,iBAAAC,OACAA,OAAAD,QAAAD,IACA,mBAAAG,eAAAC,IACAD,OAAA,SAAAH,GACA,iBAAAC,QACAA,QAAA,IAAAD,IAEAD,EAAA,IAAAC,IARA,CASCK,OAAA,WACD,mBCTA,IAAAC,EAAA,GAGA,SAAAC,EAAAC,GAGA,GAAAF,EAAAE,GACA,OAAAF,EAAAE,GAAAP,QAGA,IAAAC,EAAAI,EAAAE,GAAA,CACAC,EAAAD,EACAE,GAAA,EACAT,QAAA,IAUA,OANAU,EAAAH,GAAAI,KAAAV,EAAAD,QAAAC,IAAAD,QAAAM,GAGAL,EAAAQ,GAAA,EAGAR,EAAAD,QA0DA,OArDAM,EAAAM,EAAAF,EAGAJ,EAAAO,EAAAR,EAGAC,EAAAQ,EAAA,SAAAd,EAAAe,EAAAC,GACAV,EAAAW,EAAAjB,EAAAe,IACAG,OAAAC,eAAAnB,EAAAe,EAAA,CAA0CK,YAAA,EAAAC,IAAAL,KAK1CV,EAAAgB,EAAA,SAAAtB,GACA,oBAAAuB,eAAAC,aACAN,OAAAC,eAAAnB,EAAAuB,OAAAC,YAAA,CAAwDC,MAAA,WAExDP,OAAAC,eAAAnB,EAAA,cAAiDyB,OAAA,KAQjDnB,EAAAoB,EAAA,SAAAD,EAAAE,GAEA,GADA,EAAAA,IAAAF,EAAAnB,EAAAmB,IACA,EAAAE,EAAA,OAAAF,EACA,KAAAE,GAAA,iBAAAF,QAAAG,WAAA,OAAAH,EACA,IAAAI,EAAAX,OAAAY,OAAA,MAGA,GAFAxB,EAAAgB,EAAAO,GACAX,OAAAC,eAAAU,EAAA,WAAyCT,YAAA,EAAAK,UACzC,EAAAE,GAAA,iBAAAF,EAAA,QAAAM,KAAAN,EAAAnB,EAAAQ,EAAAe,EAAAE,EAAA,SAAAA,GAAgH,OAAAN,EAAAM,IAAqBC,KAAA,KAAAD,IACrI,OAAAF,GAIAvB,EAAA2B,EAAA,SAAAhC,GACA,IAAAe,EAAAf,KAAA2B,WACA,WAA2B,OAAA3B,EAAA,SAC3B,WAAiC,OAAAA,GAEjC,OADAK,EAAAQ,EAAAE,EAAA,IAAAA,GACAA,GAIAV,EAAAW,EAAA,SAAAiB,EAAAC,GAAsD,OAAAjB,OAAAkB,UAAAC,eAAA1B,KAAAuB,EAAAC,IAGtD7B,EAAAgC,EAAA,GAIAhC,IAAAiC,EAAA,oFClFA,MAAAC,EAAAlC,EAAA,GAEAN,EAAAyC,QAAgBC,IACRF,EAAUG,WAAWD,GACdA,EAAKE,SAAS,IACbF,EAAKG,QAGN,IAAMH,EAAKE,WAAa,IAFxBF,EAAKE,2DCNpB,SAAA3C,QAAA,IAAA6C,6BAAAC,8BAAAC,OAAA,SAAAC,WACA,aAEA,IAAAC,KAAA,IACAC,SAAA,EACAC,QAAA,iBACAC,YAAAC,aAAAF,SACAG,iBAAA,uCAEAC,qBAAA,mBAAAC,OAioBAC,IA/nBA,SAAAC,QAAAC,EAAAC,EAAAC,EAAAC,GACA,gBAAAH,EAAAD,QAAA,QACA,IAAAE,IAAA,KAAAA,GAAAC,GAAAE,UAAAJ,EAAAC,EAAAC,EAAAC,GACAE,WAAAL,GAGA,SAAAM,WAAAzC,EAAA0C,GACAC,KAAA3C,QACA2C,KAAAD,OACAC,KAAAC,SAAA,EAIA,SAAAC,aAAA7C,GACA2C,KAAA3C,QACA2C,KAAAD,KAAA1C,EAAA,EACA2C,KAAAC,SAAA,EAIA,SAAAE,aAAA9C,GACA2C,KAAA3C,QAIA,SAAA+C,UAAAvC,GACA,OAAAmB,QAAAnB,KAAAmB,QAGA,SAAAE,aAAArB,GACA,OAAAA,EAAA,IACA,CAAAA,GACAA,EAAA,KACA,CAAAA,EAAA,IAAAwC,KAAAC,MAAAzC,EAAA,MACA,CAAAA,EAAA,IAAAwC,KAAAC,MAAAzC,EAAA,SAAAwC,KAAAC,MAAAzC,EAAA,OAGA,SAAA0C,aAAAC,GACAC,KAAAD,GACA,IAAAE,EAAAF,EAAAE,OACA,GAAAA,EAAA,GAAAC,WAAAH,EAAAvB,aAAA,EACA,OAAAyB,GACA,gBACA,cAAAF,EAAA,GACA,cAAAA,EAAA,GAAAA,EAAA,GAAA1B,KACA,eAAA0B,EAAA,IAAAA,EAAA,GAAAA,EAAA,GAAA1B,WAGA,OAAA0B,EAGA,SAAAC,KAAAjB,GAEA,IADA,IAAApD,EAAAoD,EAAAkB,OACA,IAAAlB,IAAApD,KACAoD,EAAAkB,OAAAtE,EAAA,EAGA,SAAAwE,YAAAF,GAGA,IAFA,IAAAG,EAAA,IAAAC,MAAAJ,GACAtE,GAAA,IACAA,EAAAsE,GACAG,EAAAzE,GAAA,EAEA,OAAAyE,EAGA,SAAAE,SAAAlD,GACA,OAAAA,EAAA,EAAAwC,KAAAC,MAAAzC,GACAwC,KAAAW,KAAAnD,GAGA,SAAAoD,IAAAC,EAAAC,GACA,IAKAC,EAAAhF,EALAiF,EAAAH,EAAAR,OACAY,EAAAH,EAAAT,OACAxD,EAAA,IAAA4D,MAAAO,GACAE,EAAA,EACAC,EAAA1C,KAEA,IAAA1C,EAAA,EAAmBA,EAAAkF,EAASlF,IAE5BmF,GADAH,EAAAF,EAAA9E,GAAA+E,EAAA/E,GAAAmF,IACAC,EAAA,IACAtE,EAAAd,GAAAgF,EAAAG,EAAAC,EAEA,KAAApF,EAAAiF,GAEAE,GADAH,EAAAF,EAAA9E,GAAAmF,KACAC,EAAA,IACAtE,EAAAd,KAAAgF,EAAAG,EAAAC,EAGA,OADAD,EAAA,GAAArE,EAAAuE,KAAAF,GACArE,EAGA,SAAAwE,OAAAR,EAAAC,GACA,OAAAD,EAAAR,QAAAS,EAAAT,OAAAO,IAAAC,EAAAC,GACAF,IAAAE,EAAAD,GAGA,SAAAS,SAAAT,EAAAK,GACA,IAGAH,EAAAhF,EAHAC,EAAA6E,EAAAR,OACAxD,EAAA,IAAA4D,MAAAzE,GACAmF,EAAA1C,KAEA,IAAA1C,EAAA,EAAmBA,EAAAC,EAAOD,IAC1BgF,EAAAF,EAAA9E,GAAAoF,EAAAD,EACAA,EAAAlB,KAAAC,MAAAc,EAAAI,GACAtE,EAAAd,GAAAgF,EAAAG,EAAAC,EACAD,GAAA,EAEA,KAAAA,EAAA,GACArE,EAAAd,KAAAmF,EAAAC,EACAD,EAAAlB,KAAAC,MAAAiB,EAAAC,GAEA,OAAAtE,EAoCA,SAAA0E,SAAAV,EAAAC,GACA,IAKA/E,EAAAyF,EALAC,EAAAZ,EAAAR,OACAqB,EAAAZ,EAAAT,OACAxD,EAAA,IAAA4D,MAAAgB,GACAE,EAAA,EACAR,EAAA1C,KAEA,IAAA1C,EAAA,EAAmBA,EAAA2F,EAAS3F,KAC5ByF,EAAAX,EAAA9E,GAAA4F,EAAAb,EAAA/E,IACA,GACAyF,GAAAL,EACAQ,EAAA,GACaA,EAAA,EACb9E,EAAAd,GAAAyF,EAEA,IAAAzF,EAAA2F,EAAqB3F,EAAA0F,EAAS1F,IAAA,CAE9B,MADAyF,EAAAX,EAAA9E,GAAA4F,GACA,GACA,CACA9E,EAAAd,KAAAyF,EACA,MAHAA,GAAAL,EAKAtE,EAAAd,GAAAyF,EAEA,KAAczF,EAAA0F,EAAS1F,IACvBc,EAAAd,GAAA8E,EAAA9E,GAGA,OADAqE,KAAAvD,GACAA,EAGA,SAAA+E,YAAAf,EAAAC,EAAApB,GACA,IAAA1C,EAQA,OAPAsD,WAAAO,EAAAC,IAAA,EACA9D,EAAAuE,SAAAV,EAAAC,IAEA9D,EAAAuE,SAAAT,EAAAD,GACAnB,MAGA,iBADA1C,EAAAkD,aAAAlD,KAEA0C,IAAA1C,MACA,IAAA6C,aAAA7C,IAEA,IAAAyC,WAAAzC,EAAA0C,GAGA,SAAAmC,cAAAhB,EAAAC,EAAApB,GACA,IAIA3D,EAAAyF,EAJAxF,EAAA6E,EAAAR,OACAxD,EAAA,IAAA4D,MAAAzE,GACAkF,GAAAJ,EACAK,EAAA1C,KAEA,IAAA1C,EAAA,EAAmBA,EAAAC,EAAOD,IAC1ByF,EAAAX,EAAA9E,GAAAmF,EACAA,EAAAlB,KAAAC,MAAAuB,EAAAL,GACAK,GAAAL,EACAtE,EAAAd,GAAAyF,EAAA,EAAAA,EAAAL,EAAAK,EAGA,uBADA3E,EAAAqD,aAAArD,KAEA6C,IAAA7C,MACA,IAAAgD,aAAAhD,IACS,IAAA4C,WAAA5C,EAAA6C,GA0DT,SAAAoC,aAAAjB,EAAAC,GACA,IAKAiB,EAAAb,EAAAnF,EAAAiG,EALAP,EAAAZ,EAAAR,OACAqB,EAAAZ,EAAAT,OAEAxD,EAAA0D,YADAkB,EAAAC,GAEAP,EAAA1C,KAEA,IAAA1C,EAAA,EAAmBA,EAAA0F,IAAS1F,EAAA,CAC5BiG,EAAAnB,EAAA9E,GACA,QAAAkG,EAAA,EAA2BA,EAAAP,IAASO,EAEpCF,EAAAC,EADAlB,EAAAmB,GACApF,EAAAd,EAAAkG,GACAf,EAAAlB,KAAAC,MAAA8B,EAAAZ,GACAtE,EAAAd,EAAAkG,GAAAF,EAAAb,EAAAC,EACAtE,EAAAd,EAAAkG,EAAA,IAAAf,EAIA,OADAd,KAAAvD,GACAA,EAGA,SAAAqF,cAAArB,EAAAC,GACA,IAIAiB,EAAAhG,EAJAC,EAAA6E,EAAAR,OACAxD,EAAA,IAAA4D,MAAAzE,GACAmF,EAAA1C,KACAyC,EAAA,EAEA,IAAAnF,EAAA,EAAmBA,EAAAC,EAAOD,IAC1BgG,EAAAlB,EAAA9E,GAAA+E,EAAAI,EACAA,EAAAlB,KAAAC,MAAA8B,EAAAZ,GACAtE,EAAAd,GAAAgG,EAAAb,EAAAC,EAEA,KAAAD,EAAA,GACArE,EAAAd,KAAAmF,EAAAC,EACAD,EAAAlB,KAAAC,MAAAiB,EAAAC,GAEA,OAAAtE,EAGA,SAAAsF,UAAA3B,EAAAhD,GAEA,IADA,IAAAX,EAAA,GACAW,KAAA,GAAAX,EAAAuE,KAAA,GACA,OAAAvE,EAAAuF,OAAA5B,GAGA,SAAA6B,kBAAA7B,EAAA8B,GACA,IAAA9E,EAAAwC,KAAAuC,IAAA/B,EAAAH,OAAAiC,EAAAjC,QAEA,GAAA7C,GAAA,UAAAsE,aAAAtB,EAAA8B,GACA9E,EAAAwC,KAAAW,KAAAnD,EAAA,GAEA,IAAAsD,EAAAN,EAAAgC,MAAAhF,GACAqD,EAAAL,EAAAgC,MAAA,EAAAhF,GACAnB,EAAAiG,EAAAE,MAAAhF,GACApB,EAAAkG,EAAAE,MAAA,EAAAhF,GAEAiF,EAAAJ,kBAAAxB,EAAAzE,GACAsG,EAAAL,kBAAAvB,EAAAzE,GACAsG,EAAAN,kBAAAhB,OAAAR,EAAAC,GAAAO,OAAAjF,EAAAC,IAEA0F,EAAAV,cAAAoB,EAAAN,UAAAZ,kBAAAoB,EAAAF,GAAAC,GAAAlF,IAAA2E,UAAAO,EAAA,EAAAlF,IAEA,OADA4C,KAAA2B,GACAA,EAKA,SAAAa,aAAAC,EAAAC,GACA,YAAAD,EAAA,KAAAC,EAAA,MAAAD,EAAAC,EAAA,EAyBA,SAAAC,sBAAAlC,EAAAC,EAAApB,GACA,OACA,IAAAD,WADAoB,EAAApC,KACAyD,cAAApB,EAAAD,GAEAiB,aAAAhB,EAAAjC,aAAAgC,IAFAnB,GA0BA,SAAAsD,OAAAnC,GAEA,IAGAkB,EAAAb,EAAAnF,EAAAiG,EAHAhG,EAAA6E,EAAAR,OACAxD,EAAA0D,YAAAvE,KACAmF,EAAA1C,KAEA,IAAA1C,EAAA,EAAmBA,EAAAC,EAAOD,IAAA,CAE1BmF,EAAA,GADAc,EAAAnB,EAAA9E,IACAiG,EACA,QAAAC,EAAAlG,EAA2BkG,EAAAjG,EAAOiG,IAElCF,EAAAC,EADAnB,EAAAoB,GACA,EAAApF,EAAAd,EAAAkG,GAAAf,EACAA,EAAAlB,KAAAC,MAAA8B,EAAAZ,GACAtE,EAAAd,EAAAkG,GAAAF,EAAAb,EAAAC,EAEAtE,EAAAd,EAAAC,GAAAkF,EAGA,OADAd,KAAAvD,GACAA,EAiBA,SAAAoG,QAAApC,EAAAC,GACA,IASAoC,EAAAC,EAAAjC,EAAAS,EAAA5F,EAAAC,EAAAoH,EATA3B,EAAAZ,EAAAR,OACAqB,EAAAZ,EAAAT,OACAc,EAAA1C,KACA4E,EAAA9C,YAAAO,EAAAT,QACAiD,EAAAxC,EAAAY,EAAA,GAEA6B,EAAAvD,KAAAW,KAAAQ,GAAA,EAAAmC,IACAE,EAAAtB,cAAArB,EAAA0C,GACAE,EAAAvB,cAAApB,EAAAyC,GAKA,IAHAC,EAAAnD,QAAAoB,GAAA+B,EAAApC,KAAA,GACAqC,EAAArC,KAAA,GACAkC,EAAAG,EAAA/B,EAAA,GACAyB,EAAA1B,EAAAC,EAA+ByB,GAAA,EAAYA,IAAA,CAS3C,IARAD,EAAA/B,EAAA,EACAqC,EAAAL,EAAAzB,KAAA4B,IACAJ,EAAAlD,KAAAC,OAAAuD,EAAAL,EAAAzB,GAAAP,EAAAqC,EAAAL,EAAAzB,EAAA,IAAA4B,IAGApC,EAAA,EACAS,EAAA,EACA3F,EAAAyH,EAAApD,OACAtE,EAAA,EAAuBA,EAAAC,EAAOD,IAC9BmF,GAAAgC,EAAAO,EAAA1H,GACAqH,EAAApD,KAAAC,MAAAiB,EAAAC,GACAQ,GAAA6B,EAAAL,EAAApH,IAAAmF,EAAAkC,EAAAjC,GACAD,EAAAkC,EACAzB,EAAA,GACA6B,EAAAL,EAAApH,GAAA4F,EAAAR,EACAQ,GAAA,IAEA6B,EAAAL,EAAApH,GAAA4F,EACAA,EAAA,GAGA,SAAAA,GAAA,CAGA,IAFAuB,GAAA,EACAhC,EAAA,EACAnF,EAAA,EAA2BA,EAAAC,EAAOD,KAClCmF,GAAAsC,EAAAL,EAAApH,GAAAoF,EAAAsC,EAAA1H,IACA,GACAyH,EAAAL,EAAApH,GAAAmF,EAAAC,EACAD,EAAA,IAEAsC,EAAAL,EAAApH,GAAAmF,EACAA,EAAA,GAGAS,GAAAT,EAEAmC,EAAAF,GAAAD,EAIA,OADAM,EAAAE,YAAAF,EAAAD,GAAA,GACA,CAAArD,aAAAmD,GAAAnD,aAAAsD,IAGA,SAAAG,QAAA9C,EAAAC,GAQA,IANA,IAKA8C,EAAAC,EAAAC,EAAAC,EAAAC,EALAvC,EAAAZ,EAAAR,OACAqB,EAAAZ,EAAAT,OACAgD,EAAA,GACAY,EAAA,GACA9C,EAAA1C,KAEAgD,GAGA,GAFAwC,EAAAC,QAAArD,IAAAY,IACArB,KAAA6D,GACA3D,WAAA2D,EAAAnD,GAAA,EACAuC,EAAAjC,KAAA,OADA,CAKA0C,EAAAG,GADAJ,EAAAI,EAAA5D,QACA,GAAAc,EAAA8C,EAAAJ,EAAA,GACAE,EAAAjD,EAAAY,EAAA,GAAAP,EAAAL,EAAAY,EAAA,GACAmC,EAAAnC,IACAoC,KAAA,GAAA3C,GAEAyC,EAAA5D,KAAAW,KAAAmD,EAAAC,GACA,GAEA,GAAAzD,WADA0D,EAAA9B,cAAApB,EAAA8C,GACAK,IAAA,QACAL,UACaA,GACbP,EAAAjC,KAAAwC,GACAK,EAAA1C,SAAA0C,EAAAD,GAGA,OADAX,EAAAc,UACA,CAAAjE,aAAAmD,GAAAnD,aAAA+D,IAGA,SAAAP,YAAA1G,EAAAuG,GACA,IAGAxH,EAAAqH,EAAAI,EAAAC,EAHApD,EAAArD,EAAAqD,OACA+D,EAAA7D,YAAAF,GACAc,EAAA1C,KAGA,IADA+E,EAAA,EACAzH,EAAAsE,EAAA,EAA4BtE,GAAA,IAAQA,EAGpCyH,GAFAC,EAAAD,EAAArC,EAAAnE,EAAAjB,KACAqH,EAAA1C,SAAA+C,EAAAF,IACAA,EACAa,EAAArI,GAAA,EAAAqH,EAEA,OAAAgB,EAAA,EAAAZ,GAGA,SAAAa,UAAAC,EAAAnF,GACA,IAAAnC,EAAAQ,EAAAgC,WAAAL,GACA,GAAAJ,qBACA,WAAAe,aAAAwE,EAAAtH,MAAAQ,EAAAR,OAAA,IAAA8C,aAAAwE,EAAAtH,MAAAQ,EAAAR,QAEA,IACAoH,EADAvD,EAAAyD,EAAAtH,MAAA8D,EAAAtD,EAAAR,MAEA,OAAA8D,EAAA,UAAAyD,MAAA,yBACA,GAAAD,EAAA1E,QACA,OAAApC,EAAAoC,QACA,KAAAC,aAAAa,SAAAG,EAAAC,IAAA,IAAAjB,aAAAgB,EAAAC,IAEA,CAAA5B,QAAA,GAAAoF,GAEA,GAAA9G,EAAAoC,QAAA,CACA,OAAAkB,EAAA,OAAAwD,EAAApF,QAAA,IACA,OAAA4B,EAAA,OAAAwD,EAAAE,SAAAtF,QAAA,IACA,IAAAuF,EAAAzE,KAAAyE,IAAA3D,GACA,GAAA2D,EAAAhG,KAAA,CAEA2F,EAAAlE,cADAlD,EAAA0G,YAAA7C,EAAA4D,IACA,IACA,IAAAjB,EAAAxG,EAAA,GAEA,OADAsH,EAAA5E,OAAA8D,MACA,iBAAAY,GACAE,EAAA5E,OAAAlC,EAAAkC,OAAA0E,MACA,KAAAvE,aAAAuE,GAAA,IAAAvE,aAAA2D,KAEA,KAAA/D,WAAA2E,EAAAE,EAAA5E,OAAAlC,EAAAkC,MAAA,IAAAG,aAAA2D,IAEA1C,EAAAjC,aAAA4F,GAEA,IAAAC,EAAApE,WAAAO,EAAAC,GACA,QAAA4D,EAAA,OAAAxF,QAAA,GAAAoF,GACA,OAAAI,EAAA,OAAAxF,QAAAoF,EAAA5E,OAAAlC,EAAAkC,KAAA,MAAAR,QAAA,IAOAkF,GAHApH,EADA6D,EAAAR,OAAAS,EAAAT,QAAA,IACA4C,QAAApC,EAAAC,GACA6C,QAAA9C,EAAAC,IAEA,GACA,IAAA6D,EAAAL,EAAA5E,OAAAlC,EAAAkC,KACAkF,EAAA5H,EAAA,GACA6H,EAAAP,EAAA5E,KASA,MARA,iBAAA0E,GACAO,IAAAP,MACAA,EAAA,IAAAvE,aAAAuE,IACSA,EAAA,IAAA3E,WAAA2E,EAAAO,GACT,iBAAAC,GACAC,IAAAD,MACAA,EAAA,IAAA/E,aAAA+E,IACSA,EAAA,IAAAnF,WAAAmF,EAAAC,GACT,CAAAT,EAAAQ,GAwFA,SAAAtE,WAAAO,EAAAC,GACA,GAAAD,EAAAR,SAAAS,EAAAT,OACA,OAAAQ,EAAAR,OAAAS,EAAAT,OAAA,KAEA,QAAAtE,EAAA8E,EAAAR,OAAA,EAAkCtE,GAAA,EAAQA,IAC1C,GAAA8E,EAAA9E,KAAA+E,EAAA/E,GAAA,OAAA8E,EAAA9E,GAAA+E,EAAA/E,GAAA,KAEA,SAoLA,SAAA+I,aAAA3F,GACA,IAAA3B,EAAA2B,EAAAsF,MACA,OAAAjH,EAAAuH,cACAvH,EAAAwH,OAAA,IAAAxH,EAAAwH,OAAA,IAAAxH,EAAAwH,OAAA,OACAxH,EAAAyH,UAAAzH,EAAA0H,cAAA,IAAA1H,EAAA0H,cAAA,QACA1H,EAAA2H,OAAA,cAIA,SAAAC,gBAAA5H,EAAAqD,GAKA,IAJA,IAGAxE,EAAAN,EAAAyE,EAHA6E,EAAA7H,EAAA8H,OACAxE,EAAAuE,EACAxI,EAAA,EAEAiE,EAAAmE,UAAAnE,IAAAyE,OAAA,GAAA1I,IACA2I,EAAA,IAAAzJ,EAAA,EAAyBA,EAAA8E,EAAAR,OAActE,IACvC,IAAAyB,EAAA2H,OAAAtE,EAAA9E,OACAyE,EAAAjC,OAAAsC,EAAA9E,IAAA0J,OAAA3E,EAAAtD,IACAuH,WAAAvE,EAAAwE,OAAAK,GAAA,CACA,IAAAhJ,EAAAQ,EAAA,EAA2B,GAAAR,EAAQA,IAAA,CAEnC,IADAmE,IAAAwC,SAAA4B,IAAApH,IACAuH,SAAA,SACA,GAAAvE,EAAAwE,OAAAK,GAAA,SAAAG,EAEA,SAEA,SA12BA/F,WAAA9B,UAAAlB,OAAAY,OAAA6B,QAAAvB,WAOAkC,aAAAlC,UAAAlB,OAAAY,OAAA6B,QAAAvB,WAKAmC,aAAAnC,UAAAlB,OAAAY,OAAA6B,QAAAvB,WA4FA8B,WAAA9B,UAAAiD,IAAA,SAAAzB,GACA,IAAA3B,EAAAgC,WAAAL,GACA,GAAAQ,KAAAD,OAAAlC,EAAAkC,KACA,OAAAC,KAAA4B,SAAA/D,EAAAgH,UAEA,IAAA3D,EAAAlB,KAAA3C,MAAA8D,EAAAtD,EAAAR,MACA,OAAAQ,EAAAoC,QACA,IAAAH,WAAA6B,SAAAT,EAAAb,KAAAyE,IAAA3D,IAAAnB,KAAAD,MAEA,IAAAD,WAAA4B,OAAAR,EAAAC,GAAAnB,KAAAD,OAEAD,WAAA9B,UAAA+H,KAAAjG,WAAA9B,UAAAiD,IAEAf,aAAAlC,UAAAiD,IAAA,SAAAzB,GACA,IAAA3B,EAAAgC,WAAAL,GACA0B,EAAAlB,KAAA3C,MACA,GAAA6D,EAAA,IAAArD,EAAAkC,KACA,OAAAC,KAAA4B,SAAA/D,EAAAgH,UAEA,IAAA1D,EAAAtD,EAAAR,MACA,GAAAQ,EAAAoC,QAAA,CACA,GAAAG,UAAAc,EAAAC,GAAA,WAAAjB,aAAAgB,EAAAC,GACAA,EAAAjC,aAAAmB,KAAAyE,IAAA3D,IAEA,WAAArB,WAAA6B,SAAAR,EAAAd,KAAAyE,IAAA5D,MAAA,IAEAhB,aAAAlC,UAAA+H,KAAA7F,aAAAlC,UAAAiD,IAEAd,aAAAnC,UAAAiD,IAAA,SAAAzB,GACA,WAAAW,aAAAH,KAAA3C,MAAAwC,WAAAL,GAAAnC,QAEA8C,aAAAnC,UAAA+H,KAAA5F,aAAAnC,UAAAiD,IAoEAnB,WAAA9B,UAAA4D,SAAA,SAAApC,GACA,IAAA3B,EAAAgC,WAAAL,GACA,GAAAQ,KAAAD,OAAAlC,EAAAkC,KACA,OAAAC,KAAAiB,IAAApD,EAAAgH,UAEA,IAAA3D,EAAAlB,KAAA3C,MAAA8D,EAAAtD,EAAAR,MACA,OAAAQ,EAAAoC,QACAiC,cAAAhB,EAAAb,KAAAyE,IAAA3D,GAAAnB,KAAAD,MACAkC,YAAAf,EAAAC,EAAAnB,KAAAD,OAEAD,WAAA9B,UAAAgI,MAAAlG,WAAA9B,UAAA4D,SAEA1B,aAAAlC,UAAA4D,SAAA,SAAApC,GACA,IAAA3B,EAAAgC,WAAAL,GACA0B,EAAAlB,KAAA3C,MACA,GAAA6D,EAAA,IAAArD,EAAAkC,KACA,OAAAC,KAAAiB,IAAApD,EAAAgH,UAEA,IAAA1D,EAAAtD,EAAAR,MACA,OAAAQ,EAAAoC,QACA,IAAAC,aAAAgB,EAAAC,GAEAe,cAAAf,EAAAd,KAAAyE,IAAA5D,MAAA,IAEAhB,aAAAlC,UAAAgI,MAAA9F,aAAAlC,UAAA4D,SAEAzB,aAAAnC,UAAA4D,SAAA,SAAApC,GACA,WAAAW,aAAAH,KAAA3C,MAAAwC,WAAAL,GAAAnC,QAEA8C,aAAAnC,UAAAgI,MAAA7F,aAAAnC,UAAA4D,SAEA9B,WAAA9B,UAAA6G,OAAA,WACA,WAAA/E,WAAAE,KAAA3C,OAAA2C,KAAAD,OAEAG,aAAAlC,UAAA6G,OAAA,WACA,IAAA9E,EAAAC,KAAAD,KACAkG,EAAA,IAAA/F,cAAAF,KAAA3C,OAEA,OADA4I,EAAAlG,QACAkG,GAEA9F,aAAAnC,UAAA6G,OAAA,WACA,WAAA1E,cAAAH,KAAA3C,QAGAyC,WAAA9B,UAAA8G,IAAA,WACA,WAAAhF,WAAAE,KAAA3C,OAAA,IAEA6C,aAAAlC,UAAA8G,IAAA,WACA,WAAA5E,aAAAG,KAAAyE,IAAA9E,KAAA3C,SAEA8C,aAAAnC,UAAA8G,IAAA,WACA,WAAA3E,aAAAH,KAAA3C,OAAA,EAAA2C,KAAA3C,OAAA2C,KAAA3C,QA2EAyC,WAAA9B,UAAAkI,SAAA,SAAA1G,GACA,IAGAsF,EAHAjH,EAAAgC,WAAAL,GACA0B,EAAAlB,KAAA3C,MAAA8D,EAAAtD,EAAAR,MACA0C,EAAAC,KAAAD,OAAAlC,EAAAkC,KAEA,GAAAlC,EAAAoC,QAAA,CACA,OAAAkB,EAAA,OAAA5B,QAAA,GACA,OAAA4B,EAAA,OAAAnB,KACA,QAAAmB,EAAA,OAAAnB,KAAA6E,SAEA,IADAC,EAAAzE,KAAAyE,IAAA3D,IACArC,KACA,WAAAgB,WAAAyC,cAAArB,EAAA4D,GAAA/E,GAEAoB,EAAAjC,aAAA4F,GAEA,OAAA7B,aAAA/B,EAAAR,OAAAS,EAAAT,QACA,IAAAZ,WAAA4C,kBAAAxB,EAAAC,GAAApB,GACA,IAAAD,WAAAqC,aAAAjB,EAAAC,GAAApB,IAGAD,WAAA9B,UAAAmI,MAAArG,WAAA9B,UAAAkI,SAQAhG,aAAAlC,UAAAoI,iBAAA,SAAAlF,GACA,OAAAd,UAAAc,EAAA7D,MAAA2C,KAAA3C,OACA,IAAA6C,aAAAgB,EAAA7D,MAAA2C,KAAA3C,OAEA+F,sBAAA/C,KAAAyE,IAAA5D,EAAA7D,OAAA6B,aAAAmB,KAAAyE,IAAA9E,KAAA3C,QAAA2C,KAAAD,OAAAmB,EAAAnB,OAEAD,WAAA9B,UAAAoI,iBAAA,SAAAlF,GACA,WAAAA,EAAA7D,MAAAkC,QAAA,GACA,IAAA2B,EAAA7D,MAAA2C,MACA,IAAAkB,EAAA7D,MAAA2C,KAAA6E,SACAzB,sBAAA/C,KAAAyE,IAAA5D,EAAA7D,OAAA2C,KAAA3C,MAAA2C,KAAAD,OAAAmB,EAAAnB,OAEAG,aAAAlC,UAAAkI,SAAA,SAAA1G,GACA,OAAAK,WAAAL,GAAA4G,iBAAApG,OAEAE,aAAAlC,UAAAmI,MAAAjG,aAAAlC,UAAAkI,SAEA/F,aAAAnC,UAAAkI,SAAA,SAAA1G,GACA,WAAAW,aAAAH,KAAA3C,MAAAwC,WAAAL,GAAAnC,QAEA8C,aAAAnC,UAAAmI,MAAAhG,aAAAnC,UAAAkI,SAuBApG,WAAA9B,UAAAqF,OAAA,WACA,WAAAvD,WAAAuD,OAAArD,KAAA3C,QAAA,IAGA6C,aAAAlC,UAAAqF,OAAA,WACA,IAAAhG,EAAA2C,KAAA3C,MAAA2C,KAAA3C,MACA,OAAA+C,UAAA/C,GAAA,IAAA6C,aAAA7C,GACA,IAAAyC,WAAAuD,OAAAnE,aAAAmB,KAAAyE,IAAA9E,KAAA3C,UAAA,IAGA8C,aAAAnC,UAAAqF,OAAA,SAAA7D,GACA,WAAAW,aAAAH,KAAA3C,MAAA2C,KAAA3C,QAqKAyC,WAAA9B,UAAAqI,OAAA,SAAA7G,GACA,IAAAkE,EAAAgB,UAAA1E,KAAAR,GACA,OACAiF,SAAAf,EAAA,GACAG,UAAAH,EAAA,KAGAvD,aAAAnC,UAAAqI,OAAAnG,aAAAlC,UAAAqI,OAAAvG,WAAA9B,UAAAqI,OAGAvG,WAAA9B,UAAA4H,OAAA,SAAApG,GACA,OAAAkF,UAAA1E,KAAAR,GAAA,IAEAW,aAAAnC,UAAAsI,KAAAnG,aAAAnC,UAAA4H,OAAA1F,aAAAlC,UAAAsI,KAAApG,aAAAlC,UAAA4H,OAAA9F,WAAA9B,UAAAsI,KAAAxG,WAAA9B,UAAA4H,OAEA9F,WAAA9B,UAAAiH,IAAA,SAAAzF,GACA,OAAAkF,UAAA1E,KAAAR,GAAA,IAEAW,aAAAnC,UAAAiH,IAAA9E,aAAAnC,UAAA6F,UAAA3D,aAAAlC,UAAA6F,UAAA3D,aAAAlC,UAAAiH,IAAAnF,WAAA9B,UAAA6F,UAAA/D,WAAA9B,UAAAiH,IAEAnF,WAAA9B,UAAAsB,IAAA,SAAAE,GACA,IAGAnC,EAAAwD,EAAA8B,EAHA9E,EAAAgC,WAAAL,GACA0B,EAAAlB,KAAA3C,MACA8D,EAAAtD,EAAAR,MAEA,OAAA8D,EAAA,OAAA5B,QAAA,GACA,OAAA2B,EAAA,OAAA3B,QAAA,GACA,OAAA2B,EAAA,OAAA3B,QAAA,GACA,QAAA2B,EAAA,OAAArD,EAAAyH,SAAA/F,QAAA,GAAAA,SAAA,GACA,GAAA1B,EAAAkC,KACA,OAAAR,QAAA,GAEA,IAAA1B,EAAAoC,QAAA,UAAA2E,MAAA,gBAAA/G,EAAAW,WAAA,kBACA,GAAAwB,KAAAC,SACAG,UAAA/C,EAAAgD,KAAAf,IAAA4B,EAAAC,IACA,WAAAjB,aAAAa,SAAA1D,IAIA,IAFAwD,EAAAb,KACA2C,EAAApD,QAAA,IAEA,EAAA4B,IACAwB,IAAAwD,MAAAtF,KACAM,GAEA,IAAAA,GACAA,GAAA,EACAN,IAAAwC,SAEA,OAAAV,GAEAzC,aAAAlC,UAAAsB,IAAAQ,WAAA9B,UAAAsB,IAGAF,uBAEAE,IAAAiH,KAAA,gBAGApG,aAAAnC,UAAAsB,IAAA,SAAAE,GACA,IAAA3B,EAAAgC,WAAAL,GACA0B,EAAAlB,KAAA3C,MAAA8D,EAAAtD,EAAAR,MACA,OAAA8D,IAAA9B,OAAA,GAAAE,QAAA,GACA2B,IAAA7B,OAAA,GAAAE,QAAA,GACA2B,IAAA7B,OAAA,GAAAE,QAAA,GACA2B,IAAA7B,QAAA,GAAAxB,EAAAyH,SAAA/F,QAAA,GAAAA,SAAA,GACA1B,EAAA2I,aAAA,IAAArG,aAAAd,OAAA,IACA,IAAAc,aAAAb,IAAA4B,EAAAC,KAGArB,WAAA9B,UAAA8H,OAAA,SAAAW,EAAAxB,GAGA,GAFAwB,EAAA5G,WAAA4G,IACAxB,EAAApF,WAAAoF,IACAyB,SAAA,UAAA9B,MAAA,qCAGA,IAFA,IAAA1H,EAAAqC,QAAA,GACAiC,EAAAxB,KAAAiF,OACAwB,EAAAE,cAAA,CACA,GAAAnF,EAAAkF,SAAA,OAAAnH,QAAA,GACAkH,EAAAG,UAAA1J,IAAAgJ,SAAA1E,GAAAyD,QACAwB,IAAAb,OAAA,GACApE,IAAA6B,SAAA4B,OAEA,OAAA/H,GAEAiD,aAAAnC,UAAA8H,OAAA5F,aAAAlC,UAAA8H,OAAAhG,WAAA9B,UAAA8H,OAYAhG,WAAA9B,UAAA2C,WAAA,SAAAnB,GACA,IAAA3B,EAAAgC,WAAAL,GACA0B,EAAAlB,KAAA3C,MACA8D,EAAAtD,EAAAR,MACA,OAAAQ,EAAAoC,QAAA,EACAU,WAAAO,EAAAC,IAEAjB,aAAAlC,UAAA2C,WAAA,SAAAnB,GACA,IAAA3B,EAAAgC,WAAAL,GACA0B,EAAAb,KAAAyE,IAAA9E,KAAA3C,OACA8D,EAAAtD,EAAAR,MACA,OAAAQ,EAAAoC,QAEAiB,KADAC,EAAAd,KAAAyE,IAAA3D,IACA,EAAAD,EAAAC,EAAA,MAEA,GAEAhB,aAAAnC,UAAA2C,WAAA,SAAAnB,GACA,IAAA0B,EAAAlB,KAAA3C,MACA8D,EAAAtB,WAAAL,GAAAnC,MAGA,OAFA6D,KAAA,EAAAA,SACAC,KAAA,EAAAA,MACA,EAAAD,EAAAC,EAAA,MAGArB,WAAA9B,UAAA6I,QAAA,SAAArH,GAGA,GAAAA,IAAAsH,IACA,SAEA,GAAAtH,KAAAsH,IACA,SAGA,IAAAjJ,EAAAgC,WAAAL,GACA0B,EAAAlB,KAAA3C,MACA8D,EAAAtD,EAAAR,MACA,OAAA2C,KAAAD,OAAAlC,EAAAkC,KACAlC,EAAAkC,KAAA,KAEAlC,EAAAoC,QACAD,KAAAD,MAAA,IAEAY,WAAAO,EAAAC,IAAAnB,KAAAD,MAAA,MAEAD,WAAA9B,UAAA+I,UAAAjH,WAAA9B,UAAA6I,QAEA3G,aAAAlC,UAAA6I,QAAA,SAAArH,GACA,GAAAA,IAAAsH,IACA,SAEA,GAAAtH,KAAAsH,IACA,SAGA,IAAAjJ,EAAAgC,WAAAL,GACA0B,EAAAlB,KAAA3C,MACA8D,EAAAtD,EAAAR,MACA,OAAAQ,EAAAoC,QACAiB,GAAAC,EAAA,EAAAD,EAAAC,EAAA,KAEAD,EAAA,IAAArD,EAAAkC,KACAmB,EAAA,OAEAA,EAAA,QAEAhB,aAAAlC,UAAA+I,UAAA7G,aAAAlC,UAAA6I,QAEA1G,aAAAnC,UAAA6I,QAAA,SAAArH,GACA,GAAAA,IAAAsH,IACA,SAEA,GAAAtH,KAAAsH,IACA,SAEA,IAAA5F,EAAAlB,KAAA3C,MACA8D,EAAAtB,WAAAL,GAAAnC,MACA,OAAA6D,IAAAC,EAAA,EAAAD,EAAAC,EAAA,MAEAhB,aAAAnC,UAAA+I,UAAA5G,aAAAnC,UAAA6I,QAEA/G,WAAA9B,UAAAqH,OAAA,SAAA7F,GACA,WAAAQ,KAAA6G,QAAArH,IAEAW,aAAAnC,UAAAgJ,GAAA7G,aAAAnC,UAAAqH,OAAAnF,aAAAlC,UAAAgJ,GAAA9G,aAAAlC,UAAAqH,OAAAvF,WAAA9B,UAAAgJ,GAAAlH,WAAA9B,UAAAqH,OAEAvF,WAAA9B,UAAAiJ,UAAA,SAAAzH,GACA,WAAAQ,KAAA6G,QAAArH,IAEAW,aAAAnC,UAAAkJ,IAAA/G,aAAAnC,UAAAiJ,UAAA/G,aAAAlC,UAAAkJ,IAAAhH,aAAAlC,UAAAiJ,UAAAnH,WAAA9B,UAAAkJ,IAAApH,WAAA9B,UAAAiJ,UAEAnH,WAAA9B,UAAAmJ,QAAA,SAAA3H,GACA,OAAAQ,KAAA6G,QAAArH,GAAA,GAEAW,aAAAnC,UAAAoJ,GAAAjH,aAAAnC,UAAAmJ,QAAAjH,aAAAlC,UAAAoJ,GAAAlH,aAAAlC,UAAAmJ,QAAArH,WAAA9B,UAAAoJ,GAAAtH,WAAA9B,UAAAmJ,QAEArH,WAAA9B,UAAAwH,OAAA,SAAAhG,GACA,OAAAQ,KAAA6G,QAAArH,GAAA,GAEAW,aAAAnC,UAAAqJ,GAAAlH,aAAAnC,UAAAwH,OAAAtF,aAAAlC,UAAAqJ,GAAAnH,aAAAlC,UAAAwH,OAAA1F,WAAA9B,UAAAqJ,GAAAvH,WAAA9B,UAAAwH,OAEA1F,WAAA9B,UAAAsJ,gBAAA,SAAA9H,GACA,OAAAQ,KAAA6G,QAAArH,IAAA,GAEAW,aAAAnC,UAAAuJ,IAAApH,aAAAnC,UAAAsJ,gBAAApH,aAAAlC,UAAAuJ,IAAArH,aAAAlC,UAAAsJ,gBAAAxH,WAAA9B,UAAAuJ,IAAAzH,WAAA9B,UAAAsJ,gBAEAxH,WAAA9B,UAAAwJ,eAAA,SAAAhI,GACA,OAAAQ,KAAA6G,QAAArH,IAAA,GAEAW,aAAAnC,UAAAyJ,IAAAtH,aAAAnC,UAAAwJ,eAAAtH,aAAAlC,UAAAyJ,IAAAvH,aAAAlC,UAAAwJ,eAAA1H,WAAA9B,UAAAyJ,IAAA3H,WAAA9B,UAAAwJ,eAEA1H,WAAA9B,UAAAsH,OAAA,WACA,aAAAtF,KAAA3C,MAAA,KAEA6C,aAAAlC,UAAAsH,OAAA,WACA,aAAAtF,KAAA3C,QAEA8C,aAAAnC,UAAAsH,OAAA,WACA,OAAAtF,KAAA3C,MAAAgC,OAAA,MAAAA,OAAA,IAGAS,WAAA9B,UAAA4I,MAAA,WACA,aAAA5G,KAAA3C,MAAA,KAEA6C,aAAAlC,UAAA4I,MAAA,WACA,aAAA5G,KAAA3C,QAEA8C,aAAAnC,UAAA4I,MAAA,WACA,OAAA5G,KAAA3C,MAAAgC,OAAA,MAAAA,OAAA,IAGAS,WAAA9B,UAAA2I,WAAA,WACA,OAAA3G,KAAAD,MAEAG,aAAAlC,UAAA2I,WAAA,WACA,OAAA3G,KAAA3C,MAAA,GAEA8C,aAAAnC,UAAA2I,WAAAzG,aAAAlC,UAAA2I,WAEA7G,WAAA9B,UAAAwI,WAAA,WACA,OAAAxG,KAAAD,MAEAG,aAAAlC,UAAAwI,WAAA,WACA,OAAAxG,KAAA3C,MAAA,GAEA8C,aAAAnC,UAAAwI,WAAAtG,aAAAlC,UAAAwI,WAEA1G,WAAA9B,UAAAoH,OAAA,WACA,UAEAlF,aAAAlC,UAAAoH,OAAA,WACA,WAAA/E,KAAAyE,IAAA9E,KAAA3C,QAEA8C,aAAAnC,UAAAoH,OAAA,WACA,OAAApF,KAAA8E,MAAAzH,QAAAgC,OAAA,IAGAS,WAAA9B,UAAA0I,OAAA,WACA,UAEAxG,aAAAlC,UAAA0I,OAAA,WACA,WAAA1G,KAAA3C,OAEA8C,aAAAnC,UAAA0I,OAAA,WACA,OAAA1G,KAAA3C,QAAAgC,OAAA,IAGAS,WAAA9B,UAAAuH,cAAA,SAAA/F,GACA,IAAA3B,EAAAgC,WAAAL,GACA,OAAA3B,EAAA6I,aACA7I,EAAAuH,WACA,IAAAvH,EAAA8C,WAAA,GAAAX,KAAAsF,SACAtF,KAAAiF,IAAApH,GAAA6I,YAEAvG,aAAAnC,UAAAuH,cAAArF,aAAAlC,UAAAuH,cAAAzF,WAAA9B,UAAAuH,cAgCAzF,WAAA9B,UAAA0J,QAAA,SAAAC,GACA,IAAAD,EAAAvC,aAAAnF,MACA,GAAA0H,IAAA7I,UAAA,OAAA6I,EACA,IAAA7J,EAAAmC,KAAA8E,MACA8C,EAAA/J,EAAAgK,YACA,GAAAD,GAAA,GACA,OAAAnC,gBAAA5H,EAAA,8CAGA,IAFA,IAAAiK,EAAAzH,KAAA0H,IAAA,GAAAH,EAAAI,aACA1K,EAAA+C,KAAAW,MAAA,IAAA2G,EAAA,EAAAtH,KAAAf,IAAAwI,EAAA,GAAAA,GACA5G,EAAA,GAAA9E,EAAA,EAA+BA,EAAAkB,EAAOlB,IACtC8E,EAAAO,KAAA7C,OAAAxC,EAAA,IAEA,OAAAqJ,gBAAA5H,EAAAqD,IAEAf,aAAAnC,UAAA0J,QAAAxH,aAAAlC,UAAA0J,QAAA5H,WAAA9B,UAAA0J,QAEA5H,WAAA9B,UAAAiK,gBAAA,SAAAC,GACA,IAAAR,EAAAvC,aAAAnF,MACA,GAAA0H,IAAA7I,UAAA,OAAA6I,EAGA,IAFA,IAAA7J,EAAAmC,KAAA8E,MACAxH,EAAA4K,IAAArJ,UAAA,EAAAqJ,EACAhH,EAAA,GAAA9E,EAAA,EAA+BA,EAAAkB,EAAOlB,IACtC8E,EAAAO,KAAA7C,OAAAuJ,YAAA,EAAAtK,EAAAmI,MAAA,KAEA,OAAAP,gBAAA5H,EAAAqD,IAEAf,aAAAnC,UAAAiK,gBAAA/H,aAAAlC,UAAAiK,gBAAAnI,WAAA9B,UAAAiK,gBAEAnI,WAAA9B,UAAAoK,OAAA,SAAAvK,GAEA,IADA,IAAA4F,EAAA4E,EAAAC,EAAAhL,EAAAsB,OAAA2J,KAAAC,EAAA5J,OAAA6J,IAAAvL,EAAA2C,WAAAhC,GAAA6K,EAAA1I,KAAA8E,OACA4D,EAAAhC,UACAjD,EAAAvG,EAAA0I,OAAA8C,GACAL,EAAA/K,EACAgL,EAAApL,EACAI,EAAAkL,EACAtL,EAAAwL,EACAF,EAAAH,EAAAzG,SAAA6B,EAAAyC,SAAAsC,IACAE,EAAAJ,EAAA1G,SAAA6B,EAAAyC,SAAAwC,IAEA,IAAAxL,EAAAkI,SAAA,UAAAR,MAAA5E,KAAAxB,WAAA,QAAAX,EAAAW,WAAA,qBAIA,OAHA,IAAAlB,EAAAuJ,QAAA,KACAvJ,IAAA2D,IAAApD,IAEAmC,KAAAwG,aACAlJ,EAAAuH,SAEAvH,GAGA6C,aAAAnC,UAAAoK,OAAAlI,aAAAlC,UAAAoK,OAAAtI,WAAA9B,UAAAoK,OAEAtI,WAAA9B,UAAA6H,KAAA,WACA,IAAAxI,EAAA2C,KAAA3C,MACA,OAAA2C,KAAAD,KACAmC,cAAA7E,EAAA,EAAA2C,KAAAD,MAEA,IAAAD,WAAA6B,SAAAtE,EAAA,GAAA2C,KAAAD,OAEAG,aAAAlC,UAAA6H,KAAA,WACA,IAAAxI,EAAA2C,KAAA3C,MACA,OAAAA,EAAA,EAAA2B,QAAA,IAAAkB,aAAA7C,EAAA,GACA,IAAAyC,WAAAb,aAAA,IAEAkB,aAAAnC,UAAA6H,KAAA,WACA,WAAA1F,aAAAH,KAAA3C,MAAAgC,OAAA,KAGAS,WAAA9B,UAAA2H,KAAA,WACA,IAAAtI,EAAA2C,KAAA3C,MACA,OAAA2C,KAAAD,KACA,IAAAD,WAAA6B,SAAAtE,EAAA,OAEA6E,cAAA7E,EAAA,EAAA2C,KAAAD,OAEAG,aAAAlC,UAAA2H,KAAA,WACA,IAAAtI,EAAA2C,KAAA3C,MACA,OAAAA,EAAA,GAAA2B,QAAA,IAAAkB,aAAA7C,EAAA,GACA,IAAAyC,WAAAb,aAAA,IAEAkB,aAAAnC,UAAA2H,KAAA,WACA,WAAAxF,aAAAH,KAAA3C,MAAAgC,OAAA,KAIA,IADA,IAAAsJ,YAAA,IACA,EAAAA,wBAAAjI,OAAA,IAAA5B,MAAA6J,YAAAlH,KAAA,EAAAkH,wBAAAjI,OAAA,IACA,IAAAkI,cAAAD,YAAAjI,OAAAmI,cAAAF,YAAAC,cAAA,GAEA,SAAAE,cAAAjL,GACA,OAAAwC,KAAAyE,IAAAjH,IAAAiB,KAsCA,SAAAiK,QAAAlI,EAAA8B,EAAAqG,GACArG,EAAA9C,WAAA8C,GAOA,IANA,IAAAsG,EAAApI,EAAA2F,aAAA0C,EAAAvG,EAAA6D,aACA2C,EAAAF,EAAApI,EAAAuI,MAAAvI,EACAwI,EAAAH,EAAAvG,EAAAyG,MAAAzG,EACA2G,EAAA,EAAAC,EAAA,EACAC,EAAA,KAAAC,EAAA,KACA/F,EAAA,IACAyF,EAAAzC,WAAA2C,EAAA3C,UAEA4C,GADAE,EAAA9E,UAAAyE,EAAAN,gBACA,GAAAb,aACAiB,IACAK,EAAAT,cAAA,EAAAS,GAIAC,GADAE,EAAA/E,UAAA2E,EAAAR,gBACA,GAAAb,aACAkB,IACAK,EAAAV,cAAA,EAAAU,GAGAJ,EAAAK,EAAA,GACAH,EAAAI,EAAA,GACA/F,EAAAjC,KAAAuH,EAAAM,EAAAC,IAGA,IADA,IAAAnI,EAAA,IAAA4H,EAAAC,EAAA,IAAAC,EAAA,KAAAtK,QAAA,GAAAA,OAAA,GACAxC,EAAAsH,EAAAhD,OAAA,EAAuCtE,GAAA,EAAQA,GAAA,EAC/CgF,IAAA8E,SAAA2C,eAAA5H,IAAArC,OAAA8E,EAAAtH,KAEA,OAAAgF,EAhEAtB,WAAA9B,UAAAwE,UAAA,SAAAhD,GACA,IAAA3B,EAAAgC,WAAAL,GAAAwI,aACA,IAAAc,cAAAjL,GACA,UAAA+G,MAAA8E,OAAA7L,GAAA,+BAEA,GAAAA,EAAA,SAAAmC,KAAA2J,YAAA9L,GACA,IAAA6F,EAAA1D,KACA,GAAA0D,EAAAgD,SAAA,OAAAhD,EACA,KAAA7F,GAAA+K,eACAlF,IAAAwC,SAAA2C,eACAhL,GAAA+K,cAAA,EAEA,OAAAlF,EAAAwC,SAAAyC,YAAA9K,KAEAsC,aAAAnC,UAAAwE,UAAAtC,aAAAlC,UAAAwE,UAAA1C,WAAA9B,UAAAwE,UAEA1C,WAAA9B,UAAA2L,WAAA,SAAAnK,GACA,IAAAoK,EACA/L,EAAAgC,WAAAL,GAAAwI,aACA,IAAAc,cAAAjL,GACA,UAAA+G,MAAA8E,OAAA7L,GAAA,+BAEA,GAAAA,EAAA,SAAAmC,KAAAwC,WAAA3E,GAEA,IADA,IAAA6F,EAAA1D,KACAnC,GAAA+K,eAAA,CACA,GAAAlF,EAAAgD,UAAAhD,EAAA8C,cAAA9C,EAAA0B,SAAA,OAAA1B,EAEAA,GADAkG,EAAAlF,UAAAhB,EAAAmF,gBACA,GAAArC,aAAAoD,EAAA,GAAAjE,OAAAiE,EAAA,GACA/L,GAAA+K,cAAA,EAGA,OADAgB,EAAAlF,UAAAhB,EAAAiF,YAAA9K,KACA,GAAA2I,aAAAoD,EAAA,GAAAjE,OAAAiE,EAAA,IAEAzJ,aAAAnC,UAAA2L,WAAAzJ,aAAAlC,UAAA2L,WAAA7J,WAAA9B,UAAA2L,WAkCA7J,WAAA9B,UAAAoL,IAAA,WACA,OAAApJ,KAAA6E,SAAAc,QAEAxF,aAAAnC,UAAAoL,IAAAlJ,aAAAlC,UAAAoL,IAAAtJ,WAAA9B,UAAAoL,IAEAtJ,WAAA9B,UAAA6L,IAAA,SAAAhM,GACA,OAAAkL,QAAA/I,KAAAnC,EAAA,SAAAqD,EAAAC,GAAiD,OAAAD,EAAAC,KAEjDhB,aAAAnC,UAAA6L,IAAA3J,aAAAlC,UAAA6L,IAAA/J,WAAA9B,UAAA6L,IAEA/J,WAAA9B,UAAA8L,GAAA,SAAAjM,GACA,OAAAkL,QAAA/I,KAAAnC,EAAA,SAAAqD,EAAAC,GAAiD,OAAAD,EAAAC,KAEjDhB,aAAAnC,UAAA8L,GAAA5J,aAAAlC,UAAA8L,GAAAhK,WAAA9B,UAAA8L,GAEAhK,WAAA9B,UAAA+L,IAAA,SAAAlM,GACA,OAAAkL,QAAA/I,KAAAnC,EAAA,SAAAqD,EAAAC,GAAiD,OAAAD,EAAAC,KAEjDhB,aAAAnC,UAAA+L,IAAA7J,aAAAlC,UAAA+L,IAAAjK,WAAA9B,UAAA+L,IAEA,IAAAC,UAAA,MAAAC,YAAAnL,yBAAAkL,UACA,SAAAE,SAAArM,GAGA,IAAA2B,EAAA3B,EAAAR,MACAwD,EAAA,iBAAArB,IAAAwK,UACA,iBAAAxK,IAAAH,OAAA2K,WACAxK,EAAA,GAAAA,EAAA,GAAAV,KAAAmL,WACA,OAAApJ,KAGA,SAAAsJ,iBAAA9M,EAAAmE,GACA,GAAAA,EAAAuF,UAAA1J,IAAA,GACA,IAAA+M,EAAAD,iBAAA9M,EAAAmE,EAAA6B,OAAA7B,IACAtD,EAAAkM,EAAAlM,EACAmM,EAAAD,EAAAC,EACA/M,EAAAY,EAAAgI,SAAA1E,GACA,OAAAlE,EAAAyJ,UAAA1J,IAAA,GAA8Ca,EAAAZ,EAAA+M,EAAA,EAAAA,EAAA,GAAqB,CAAInM,IAAAmM,EAAA,EAAAA,GAEvE,OAAgBnM,EAAAU,OAAA,GAAAyL,EAAA,GAehB,SAAAzH,IAAA1B,EAAAC,GAGA,OAFAD,EAAArB,WAAAqB,GACAC,EAAAtB,WAAAsB,GACAD,EAAAiG,QAAAhG,GAAAD,EAAAC,EAEA,SAAAmJ,IAAApJ,EAAAC,GAGA,OAFAD,EAAArB,WAAAqB,GACAC,EAAAtB,WAAAsB,GACAD,EAAAsE,OAAArE,GAAAD,EAAAC,EAEA,SAAAoJ,IAAArJ,EAAAC,GAGA,GAFAD,EAAArB,WAAAqB,GAAA4D,MACA3D,EAAAtB,WAAAsB,GAAA2D,MACA5D,EAAAmE,OAAAlE,GAAA,OAAAD,EACA,GAAAA,EAAAwF,SAAA,OAAAvF,EACA,GAAAA,EAAAuF,SAAA,OAAAxF,EAEA,IADA,IAAAxE,EAAAY,EAAAb,EAAA8C,QAAA,GACA2B,EAAAoE,UAAAnE,EAAAmE,UACA5I,EAAA4N,IAAAJ,SAAAhJ,GAAAgJ,SAAA/I,IACAD,IAAA0E,OAAAlJ,GACAyE,IAAAyE,OAAAlJ,GACAD,IAAAyJ,SAAAxJ,GAEA,KAAAwE,EAAAoE,UACApE,IAAA0E,OAAAsE,SAAAhJ,IAEA,GACA,KAAAC,EAAAmE,UACAnE,IAAAyE,OAAAsE,SAAA/I,IAEAD,EAAAiG,QAAAhG,KACA7D,EAAA6D,EAAsBA,EAAAD,EAAOA,EAAA5D,GAE7B6D,IAAAS,SAAAV,UACSC,EAAAuF,UACT,OAAAjK,EAAA2I,SAAAlE,IAAAgF,SAAAzJ,GAEA,SAAA+N,IAAAtJ,EAAAC,GAGA,OAFAD,EAAArB,WAAAqB,GAAA4D,MACA3D,EAAAtB,WAAAsB,GAAA2D,MACA5D,EAAA0E,OAAA2E,IAAArJ,EAAAC,IAAA+E,SAAA/E,GAEA,SAAAgH,YAAAjH,EAAAC,GAGA,IAAAsJ,EAAAH,IAFApJ,EAAArB,WAAAqB,GACAC,EAAAtB,WAAAsB,IAEAuJ,EADA9H,IAAA1B,EAAAC,GACAS,SAAA6I,GAAAxJ,IAAA,GACA,GAAAyJ,EAAAzK,QAAA,OAAAwK,EAAAxJ,IAAAZ,KAAAC,MAAAD,KAAAsK,SAAAD,IAGA,IAFA,IAAAE,EAAAC,OAAAH,EAAA5L,MAAAzB,MACAqG,EAAA,GAAAoH,GAAA,EACA1O,EAAA,EAAuBA,EAAAwO,EAAAlK,OAAmBtE,IAAA,CAC1C,IAAA2O,EAAAD,EAAAF,EAAAxO,GAAA0C,KACAkM,EAAAjK,SAAAV,KAAAsK,SAAAI,GACArH,EAAAjC,KAAAuJ,GACAA,EAAAD,IAAAD,GAAA,GAEA,OAAAL,EAAAxJ,IAAA1B,QAAA0L,UAAAvH,EAAA5E,MAAA,IApEAgB,WAAA9B,UAAA6J,UAAA,WACA,IAAAhK,EAAAmC,KAIA,OAHAnC,EAAAkJ,UAAAnI,OAAA,QACAf,IAAAgH,SAAAjD,SAAAhD,OAAA,KAEA,IAAAf,EAAAkJ,UAAAnI,OAAA,IACAA,OAAA,GAEAA,OAAAuL,iBAAAtM,EAAAe,OAAA,IAAAyL,GAAApJ,IAAArC,OAAA,KAEAuB,aAAAnC,UAAA6J,UAAA3H,aAAAlC,UAAA6J,UAAA/H,WAAA9B,UAAA6J,UA6DA,IAAAjI,UAAA,SAAAsL,EAAA1J,EAAA9B,EAAAC,GACAD,KAAAP,iBACA+L,EAAAxB,OAAAwB,GACAvL,IACAuL,IAAAC,cACAzL,IAAAyL,eAEA,IACA/O,EADAsE,EAAAwK,EAAAxK,OAEA0K,EAAA/K,KAAAyE,IAAAtD,GACA6J,EAAA,GACA,IAAAjP,EAAA,EAAmBA,EAAAsD,EAAAgB,OAAqBtE,IACxCiP,EAAA3L,EAAAtD,MAEA,IAAAA,EAAA,EAAmBA,EAAAsE,EAAYtE,IAAA,CAE/B,UADAK,EAAAyO,EAAA9O,MAEAK,KAAA4O,GACAA,EAAA5O,IAAA2O,GAAA,CACA,SAAA3O,GAAA,IAAA2O,EAAA,SACA,UAAAxG,MAAAnI,EAAA,iCAAA+E,EAAA,MAIAA,EAAA3B,WAAA2B,GACA,IAAAoJ,EAAA,GACApE,EAAA,MAAA0E,EAAA,GACA,IAAA9O,EAAAoK,EAAA,IAAoCpK,EAAA8O,EAAAxK,OAAiBtE,IAAA,CACrD,IAAAK,EACA,IADAA,EAAAyO,EAAA9O,MACAiP,EAAAT,EAAAnJ,KAAA5B,WAAAwL,EAAA5O,SACA,UAAAA,EAKA,UAAAmI,MAAAnI,EAAA,6BAJA,IAAA6O,EAAAlP,EACA,GAAoBA,UAAO,MAAA8O,EAAA9O,MAAA8O,EAAAxK,QAC3BkK,EAAAnJ,KAAA5B,WAAAqL,EAAArI,MAAAyI,EAAA,EAAAlP,MAIA,OAAAmP,mBAAAX,EAAApJ,EAAAgF,IAGA,SAAA+E,mBAAAX,EAAApJ,EAAAgF,GACA,IAAApK,EAAAoP,EAAAjM,QAAA,GAAAD,EAAAC,QAAA,GACA,IAAAnD,EAAAwO,EAAAlK,OAAA,EAAmCtE,GAAA,EAAQA,IAC3CoP,IAAAvK,IAAA2J,EAAAxO,GAAA+J,MAAA7G,IACAA,IAAA6G,MAAA3E,GAEA,OAAAgF,EAAAgF,EAAA3G,SAAA2G,EAGA,SAAAC,UAAAT,EAAAtL,GAEA,OAAAsL,GADAtL,KAAAP,kBACAuB,OACAhB,EAAAsL,GAEA,IAAAA,EAAA,IAGA,SAAAH,OAAAhN,EAAA2D,GAEA,IADAA,EAAA5C,OAAA4C,IACAkF,SAAA,CACA,GAAA7I,EAAA6I,SAAA,OAAoCrJ,MAAA,IAAAmJ,YAAA,GACpC,UAAA5B,MAAA,6CAEA,GAAApD,EAAA6D,QAAA,IACA,GAAAxH,EAAA6I,SAAA,OAAoCrJ,MAAA,IAAAmJ,YAAA,GACpC,GAAA3I,EAAA2I,aACA,OACAnJ,MAAA,GAAAoF,OAAAiJ,MAAA,GAAA5K,MAAA4K,MAAA,KAAA5K,OAAAjD,EAAAmK,eACA2D,IAAA7K,MAAA9C,UAAA4N,QAAA,QAEApF,YAAA,GAGA,IAAAhG,EAAAM,MAAA4K,MAAA,KAAA5K,MAAAjD,EAAAmK,aAAA,IACA2D,IAAA7K,MAAA9C,UAAA4N,QAAA,OAEA,OADApL,EAAA+D,QAAA,KACA,CACAlH,MAAA,GAAAoF,OAAAiJ,MAAA,GAAAlL,GACAgG,YAAA,GAIA,IAAAqF,GAAA,EAKA,GAJAhO,EAAA2I,cAAAhF,EAAAmF,eACAkF,GAAA,EACAhO,IAAAiH,OAEAtD,EAAA4D,SACA,OAAAvH,EAAA6I,SAAA,CAAoCrJ,MAAA,IAAAmJ,YAAA,GAEpC,CACAnJ,MAAAyD,MAAA4K,MAAA,KAAA5K,MAAAjD,EAAAmK,eACA2D,IAAAG,OAAA9N,UAAA4N,QAAA,GACApF,WAAAqF,GAKA,IAFA,IACAxF,EADA0F,EAAA,GACAC,EAAAnO,EACAmO,EAAAxF,cAAAwF,EAAArL,WAAAa,IAAA,IACA6E,EAAA2F,EAAA3F,OAAA7E,GACAwK,EAAA3F,EAAA5B,SACA,IAAAuG,EAAA3E,EAAAxC,UACAmH,EAAAxE,eACAwE,EAAAxJ,EAAAwE,MAAAgF,GAAAlG,MACAkH,IAAAnG,QAEAkG,EAAAtK,KAAAuJ,EAAAhD,cAGA,OADA+D,EAAAtK,KAAAuK,EAAAhE,cACA,CAAgB3K,MAAA0O,EAAAvH,UAAAgC,WAAAqF,GAGhB,SAAAI,aAAApO,EAAA2D,EAAA9B,GACA,IAAAc,EAAAqK,OAAAhN,EAAA2D,GACA,OAAAhB,EAAAgG,WAAA,QAAAhG,EAAAnD,MAAAsO,IAAA,SAAA9K,GACA,OAAA4K,UAAA5K,EAAAnB,KACSwM,KAAA,IAkDT,SAAAC,iBAAA3M,GACA,GAAAY,WAAAZ,GAAA,CACA,IAAAqB,GAAArB,EACA,GAAAqB,IAAAE,SAAAF,GACA,OAAAzB,qBAAA,IAAAe,aAAAd,OAAAwB,IAAA,IAAAX,aAAAW,GACA,UAAA+D,MAAA,oBAAApF,GAEA,IAAAO,EAAA,MAAAP,EAAA,GACAO,IAAAP,IAAAqD,MAAA,IACA,IAAAuJ,EAAA5M,EAAA4M,MAAA,MACA,GAAAA,EAAA1L,OAAA,YAAAkE,MAAA,oBAAAwH,EAAAF,KAAA,MACA,OAAAE,EAAA1L,OAAA,CACA,IAAA+F,EAAA2F,EAAA,GAGA,GAFA,MAAA3F,EAAA,KAAAA,IAAA5D,MAAA,KACA4D,QACA1F,SAAA0F,KAAArG,UAAAqG,GAAA,UAAA7B,MAAA,oBAAA6B,EAAA,6BACA,IAAAyE,EAAAkB,EAAA,GACAC,EAAAnB,EAAAoB,QAAA,KAKA,GAJAD,GAAA,IACA5F,GAAAyE,EAAAxK,OAAA2L,EAAA,EACAnB,IAAArI,MAAA,EAAAwJ,GAAAnB,EAAArI,MAAAwJ,EAAA,IAEA5F,EAAA,YAAA7B,MAAA,sDAEApF,EADA0L,GAAA,IAAApK,MAAA2F,EAAA,GAAAyF,KAAA,KAIA,IADA,kBAAAK,KAAA/M,GACA,UAAAoF,MAAA,oBAAApF,GACA,GAAAJ,qBACA,WAAAe,aAAAd,OAAAU,EAAA,IAAAP,MAGA,IADA,IAAAtC,EAAA,GAAA0F,EAAApD,EAAAkB,OAAArE,EAAA0C,SAAAuL,EAAA1H,EAAAvG,EACAuG,EAAA,GACA1F,EAAAuE,MAAAjC,EAAAqD,MAAAyH,EAAA1H,KACA0H,GAAAjO,GACA,IAAAiO,EAAA,GACA1H,GAAAvG,EAGA,OADAoE,KAAAvD,GACA,IAAA4C,WAAA5C,EAAA6C,GAGA,SAAAyM,iBAAAhN,GACA,GAAAJ,qBACA,WAAAe,aAAAd,OAAAG,IAEA,GAAAY,UAAAZ,GAAA,CACA,GAAAA,IAAAuB,SAAAvB,GAAA,UAAAoF,MAAApF,EAAA,uBACA,WAAAU,aAAAV,GAEA,OAAA2M,iBAAA3M,EAAAhB,YAGA,SAAAqB,WAAAL,GACA,uBAAAA,EACAgN,iBAAAhN,GAEA,iBAAAA,EACA2M,iBAAA3M,GAEA,iBAAAA,EACA,IAAAW,aAAAX,GAEAA,EA9GAM,WAAA9B,UAAAyO,QAAA,SAAAhN,GACA,OAAAoL,OAAA7K,KAAAP,IAGAS,aAAAlC,UAAAyO,QAAA,SAAAhN,GACA,OAAAoL,OAAA7K,KAAAP,IAGAU,aAAAnC,UAAAyO,QAAA,SAAAhN,GACA,OAAAoL,OAAA7K,KAAAP,IAGAK,WAAA9B,UAAAQ,SAAA,SAAAiB,EAAAC,GAEA,GADAD,IAAAZ,YAAAY,EAAA,IACA,KAAAA,EAAA,OAAAwM,aAAAjM,KAAAP,EAAAC,GAEA,IADA,IAAAsL,EAAAxL,EAAAQ,KAAA3C,MAAAhB,EAAAmD,EAAAkB,OAAAgM,EAAAhD,OAAAlK,IAAAnD,MACAA,GAAA,GACA2O,EAAAtB,OAAAlK,EAAAnD,IACAqQ,GAHA,UAGA7J,MAAAmI,EAAAtK,QAAAsK,EAGA,OADAhL,KAAAD,KAAA,QACA2M,GAGAxM,aAAAlC,UAAAQ,SAAA,SAAAiB,EAAAC,GAEA,OADAD,IAAAZ,YAAAY,EAAA,IACA,IAAAA,EAAAwM,aAAAjM,KAAAP,EAAAC,GACAgK,OAAA1J,KAAA3C,QAGA8C,aAAAnC,UAAAQ,SAAA0B,aAAAlC,UAAAQ,SAEA2B,aAAAnC,UAAA2O,OAAA7M,WAAA9B,UAAA2O,OAAAzM,aAAAlC,UAAA2O,OAAA,WAA+G,OAAA3M,KAAAxB,YAE/GsB,WAAA9B,UAAA4N,QAAA,WACA,OAAAgB,SAAA5M,KAAAxB,WAAA,KAEAsB,WAAA9B,UAAAgK,WAAAlI,WAAA9B,UAAA4N,QAEA1L,aAAAlC,UAAA4N,QAAA,WACA,OAAA5L,KAAA3C,OAEA6C,aAAAlC,UAAAgK,WAAA9H,aAAAlC,UAAA4N,QACAzL,aAAAnC,UAAA4N,QAAAzL,aAAAnC,UAAAgK,WAAA,WACA,OAAA4E,SAAA5M,KAAAxB,WAAA,KAqEA,QAAApC,EAAA,EAAmBA,EAAA,IAAUA,IAC7BmD,QAAAnD,GAAAyD,WAAAzD,GACAA,EAAA,IAAAmD,SAAAnD,GAAAyD,YAAAzD,IAiBA,OAdAmD,QAAAkJ,IAAAlJ,QAAA,GACAA,QAAAgJ,KAAAhJ,QAAA,GACAA,QAAAsN,SAAAtN,SAAA,GACAA,QAAAqD,QACArD,QAAA+K,QACA/K,QAAAgL,QACAhL,QAAAiL,QACAjL,QAAAhB,WAAA,SAAAsC,GAAuC,OAAAA,aAAAf,YAAAe,aAAAX,cAAAW,aAAAV,cACvCZ,QAAA4I,wBAEA5I,QAAA0L,UAAA,SAAAL,EAAApJ,EAAAgF,GACA,OAAA+E,mBAAAX,EAAAe,IAAA9L,uBAAA2B,GAAA,IAAAgF,IAGAjH,QA94CA,GAk5CiC1D,OAAAoC,eAAA,aACjCpC,OAAAD,QAAAgD,QAKIF,6BAAsB,GAAEC,8BAAA,WAC5B,OAAAC,QACK8M,MAAA9P,QAAA8C,mCAAAG,IAAAF,gCAAA9C,OAAAD,QAAA+C,kixsICx5CL,MAAAP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa6Q,EAMTC,YAAYC,GACRjN,KAAKrD,KAAO,QACZqD,KAAKvB,SAAU,EACfuB,KAAKiN,SAAWA,EAGpBD,WACI,MAAO,UAAYF,EAAAzO,QAAU2B,KAAKiN,UAAY,KAbtDrR,EAAAmR,QAiBAnR,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMC,EAAiBD,EAAME,MAAMC,MAC/BlP,EAAUG,WAAW6O,IAAmBA,EAAepF,eAAgBmF,EAAMI,OAC7EJ,EAAME,MAAM5L,KAAK0L,EAAMI,OAAOH,EAAepF,eAE7CmF,EAAME,MAAM5L,KAAK,IAAIsL,EAAMK,00u4DCzBnC,MAAAhP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAasR,EAOTR,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,MAAQc,EAAAzO,QAAU2B,KAAKyN,QAf7D7R,EAAA4R,MAmBA5R,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAK/G,IAAIwI,IAE1BN,EAAME,MAAM5L,KAAK,IAAI+L,EAAIxB,EAAMyB,qCC9BvC,SAAAC;;;;;;;AAUA,IAAAC,EAAazR,EAAQ,IACrB0R,EAAc1R,EAAQ,IACtB2R,EAAc3R,EAAQ,IAmDtB,SAAA4R,IACA,OAAAC,EAAAC,oBACA,WACA,WAGA,SAAAC,EAAAC,EAAAxN,GACA,GAAAoN,IAAApN,EACA,UAAAyN,WAAA,8BAcA,OAZAJ,EAAAC,qBAEAE,EAAA,IAAAE,WAAA1N,IACA2N,UAAAN,EAAA/P,WAGA,OAAAkQ,IACAA,EAAA,IAAAH,EAAArN,IAEAwN,EAAAxN,UAGAwN,EAaA,SAAAH,EAAAO,EAAAC,EAAA7N,GACA,KAAAqN,EAAAC,qBAAAhO,gBAAA+N,GACA,WAAAA,EAAAO,EAAAC,EAAA7N,GAIA,oBAAA4N,EAAA,CACA,oBAAAC,EACA,UAAA3J,MACA,qEAGA,OAAA4J,EAAAxO,KAAAsO,GAEA,OAAAG,EAAAzO,KAAAsO,EAAAC,EAAA7N,GAWA,SAAA+N,EAAAP,EAAA7Q,EAAAkR,EAAA7N,GACA,oBAAArD,EACA,UAAAqR,UAAA,yCAGA,0BAAAC,aAAAtR,aAAAsR,YA6HA,SAAAT,EAAAU,EAAAC,EAAAnO,GAGA,GAFAkO,EAAAE,WAEAD,EAAA,GAAAD,EAAAE,WAAAD,EACA,UAAAV,WAAA,6BAGA,GAAAS,EAAAE,WAAAD,GAAAnO,GAAA,GACA,UAAAyN,WAAA,6BAIAS,OADA/P,IAAAgQ,QAAAhQ,IAAA6B,EACA,IAAA0N,WAAAQ,QACG/P,IAAA6B,EACH,IAAA0N,WAAAQ,EAAAC,GAEA,IAAAT,WAAAQ,EAAAC,EAAAnO,GAGAqN,EAAAC,qBAEAE,EAAAU,GACAP,UAAAN,EAAA/P,UAGAkQ,EAAAa,EAAAb,EAAAU,GAEA,OAAAV,EAvJAc,CAAAd,EAAA7Q,EAAAkR,EAAA7N,GAGA,iBAAArD,EAwFA,SAAA6Q,EAAAe,EAAAC,GACA,iBAAAA,GAAA,KAAAA,IACAA,EAAA,QAGA,IAAAnB,EAAAoB,WAAAD,GACA,UAAAR,UAAA,8CAGA,IAAAhO,EAAA,EAAAoO,EAAAG,EAAAC,GAGAE,GAFAlB,EAAAD,EAAAC,EAAAxN,IAEA2O,MAAAJ,EAAAC,GAEAE,IAAA1O,IAIAwN,IAAArL,MAAA,EAAAuM,IAGA,OAAAlB,EA5GAoB,CAAApB,EAAA7Q,EAAAkR,GAsJA,SAAAL,EAAAqB,GACA,GAAAxB,EAAAyB,SAAAD,GAAA,CACA,IAAAE,EAAA,EAAAC,EAAAH,EAAA7O,QAGA,YAFAwN,EAAAD,EAAAC,EAAAuB,IAEA/O,OACAwN,GAGAqB,EAAAI,KAAAzB,EAAA,IAAAuB,GACAvB,GAGA,GAAAqB,EAAA,CACA,uBAAAZ,aACAY,EAAAK,kBAAAjB,aAAA,WAAAY,EACA,uBAAAA,EAAA7O,SA+8CA8K,EA/8CA+D,EAAA7O,SAg9CA8K,EA/8CAyC,EAAAC,EAAA,GAEAa,EAAAb,EAAAqB,GAGA,cAAAA,EAAAM,MAAAhC,EAAA0B,EAAAO,MACA,OAAAf,EAAAb,EAAAqB,EAAAO,MAw8CA,IAAAtE,EAp8CA,UAAAkD,UAAA,sFA9KAqB,CAAA7B,EAAA7Q,GA4BA,SAAA2S,EAAAC,GACA,oBAAAA,EACA,UAAAvB,UAAA,oCACG,GAAAuB,EAAA,EACH,UAAA9B,WAAA,wCA4BA,SAAAK,EAAAN,EAAA+B,GAGA,GAFAD,EAAAC,GACA/B,EAAAD,EAAAC,EAAA+B,EAAA,MAAAP,EAAAO,KACAlC,EAAAC,oBACA,QAAA5R,EAAA,EAAmBA,EAAA6T,IAAU7T,EAC7B8R,EAAA9R,GAAA,EAGA,OAAA8R,EAwCA,SAAAa,EAAAb,EAAAU,GACA,IAAAlO,EAAAkO,EAAAlO,OAAA,MAAAgP,EAAAd,EAAAlO,QACAwN,EAAAD,EAAAC,EAAAxN,GACA,QAAAtE,EAAA,EAAiBA,EAAAsE,EAAYtE,GAAA,EAC7B8R,EAAA9R,GAAA,IAAAwS,EAAAxS,GAEA,OAAA8R,EA+DA,SAAAwB,EAAAhP,GAGA,GAAAA,GAAAoN,IACA,UAAAK,WAAA,0DACAL,IAAAtP,SAAA,cAEA,SAAAkC,EAsFA,SAAAoO,EAAAG,EAAAC,GACA,GAAAnB,EAAAyB,SAAAP,GACA,OAAAA,EAAAvO,OAEA,uBAAAiO,aAAA,mBAAAA,YAAAuB,SACAvB,YAAAuB,OAAAjB,iBAAAN,aACA,OAAAM,EAAAH,WAEA,iBAAAG,IACAA,EAAA,GAAAA,GAGA,IAAAQ,EAAAR,EAAAvO,OACA,OAAA+O,EAAA,SAIA,IADA,IAAAU,GAAA,IAEA,OAAAjB,GACA,YACA,aACA,aACA,OAAAO,EACA,WACA,YACA,UAAA5Q,EACA,OAAAuR,EAAAnB,GAAAvO,OACA,WACA,YACA,cACA,eACA,SAAA+O,EACA,UACA,OAAAA,IAAA,EACA,aACA,OAAAY,EAAApB,GAAAvO,OACA,QACA,GAAAyP,EAAA,OAAAC,EAAAnB,GAAAvO,OACAwO,GAAA,GAAAA,GAAA/D,cACAgF,GAAA,GAgFA,SAAAG,EAAAnP,EAAAtD,EAAArB,GACA,IAAAJ,EAAA+E,EAAAtD,GACAsD,EAAAtD,GAAAsD,EAAA3E,GACA2E,EAAA3E,GAAAJ,EAmIA,SAAAmU,EAAAX,EAAApE,EAAAqD,EAAAK,EAAAsB,GAEA,OAAAZ,EAAAlP,OAAA,SAmBA,GAhBA,iBAAAmO,GACAK,EAAAL,EACAA,EAAA,GACGA,EAAA,WACHA,EAAA,WACGA,GAAA,aACHA,GAAA,YAEAA,KACA4B,MAAA5B,KAEAA,EAAA2B,EAAA,EAAAZ,EAAAlP,OAAA,GAIAmO,EAAA,IAAAA,EAAAe,EAAAlP,OAAAmO,GACAA,GAAAe,EAAAlP,OAAA,CACA,GAAA8P,EAAA,SACA3B,EAAAe,EAAAlP,OAAA,OACG,GAAAmO,EAAA,GACH,IAAA2B,EACA,SADA3B,EAAA,EAUA,GALA,iBAAArD,IACAA,EAAAuC,EAAAU,KAAAjD,EAAA0D,IAIAnB,EAAAyB,SAAAhE,GAEA,WAAAA,EAAA9K,QACA,EAEAgQ,EAAAd,EAAApE,EAAAqD,EAAAK,EAAAsB,GACG,oBAAAhF,EAEH,OADAA,GAAA,IACAuC,EAAAC,qBACA,mBAAAI,WAAApQ,UAAAsO,QACAkE,EACApC,WAAApQ,UAAAsO,QAAA/P,KAAAqT,EAAApE,EAAAqD,GAEAT,WAAApQ,UAAA2S,YAAApU,KAAAqT,EAAApE,EAAAqD,GAGA6B,EAAAd,EAAA,CAAApE,GAAAqD,EAAAK,EAAAsB,GAGA,UAAA9B,UAAA,wCAGA,SAAAgC,EAAAlQ,EAAAgL,EAAAqD,EAAAK,EAAAsB,GACA,IA0BApU,EA1BAwU,EAAA,EACAC,EAAArQ,EAAAE,OACAoQ,EAAAtF,EAAA9K,OAEA,QAAA7B,IAAAqQ,IAEA,UADAA,EAAAxF,OAAAwF,GAAA/D,gBACA,UAAA+D,GACA,YAAAA,GAAA,aAAAA,GAAA,CACA,GAAA1O,EAAAE,OAAA,GAAA8K,EAAA9K,OAAA,EACA,SAEAkQ,EAAA,EACAC,GAAA,EACAC,GAAA,EACAjC,GAAA,EAIA,SAAAkC,EAAAC,EAAA5U,GACA,WAAAwU,EACAI,EAAA5U,GAEA4U,EAAAC,aAAA7U,EAAAwU,GAKA,GAAAJ,EAAA,CACA,IAAAU,GAAA,EACA,IAAA9U,EAAAyS,EAAwBzS,EAAAyU,EAAezU,IACvC,GAAA2U,EAAAvQ,EAAApE,KAAA2U,EAAAvF,GAAA,IAAA0F,EAAA,EAAA9U,EAAA8U,IAEA,IADA,IAAAA,MAAA9U,GACAA,EAAA8U,EAAA,IAAAJ,EAAA,OAAAI,EAAAN,OAEA,IAAAM,IAAA9U,KAAA8U,GACAA,GAAA,OAKA,IADArC,EAAAiC,EAAAD,IAAAhC,EAAAgC,EAAAC,GACA1U,EAAAyS,EAAwBzS,GAAA,EAAQA,IAAA,CAEhC,IADA,IAAA+U,GAAA,EACA7O,EAAA,EAAqBA,EAAAwO,EAAexO,IACpC,GAAAyO,EAAAvQ,EAAApE,EAAAkG,KAAAyO,EAAAvF,EAAAlJ,GAAA,CACA6O,GAAA,EACA,MAGA,GAAAA,EAAA,OAAA/U,EAIA,SAeA,SAAAgV,EAAAJ,EAAA/B,EAAAoC,EAAA3Q,GACA2Q,EAAAvF,OAAAuF,IAAA,EACA,IAAAC,EAAAN,EAAAtQ,OAAA2Q,EACA3Q,GAGAA,EAAAoL,OAAApL,IACA4Q,IACA5Q,EAAA4Q,GAJA5Q,EAAA4Q,EASA,IAAAC,EAAAtC,EAAAvO,OACA,GAAA6Q,EAAA,eAAA7C,UAAA,sBAEAhO,EAAA6Q,EAAA,IACA7Q,EAAA6Q,EAAA,GAEA,QAAAnV,EAAA,EAAiBA,EAAAsE,IAAYtE,EAAA,CAC7B,IAAAoV,EAAA5E,SAAAqC,EAAAwC,OAAA,EAAArV,EAAA,OACA,GAAAqU,MAAAe,GAAA,OAAApV,EACA4U,EAAAK,EAAAjV,GAAAoV,EAEA,OAAApV,EAGA,SAAAsV,EAAAV,EAAA/B,EAAAoC,EAAA3Q,GACA,OAAAiR,EAAAvB,EAAAnB,EAAA+B,EAAAtQ,OAAA2Q,GAAAL,EAAAK,EAAA3Q,GAGA,SAAAkR,EAAAZ,EAAA/B,EAAAoC,EAAA3Q,GACA,OAAAiR,EAq6BA,SAAAjF,GAEA,IADA,IAAAmF,EAAA,GACAzV,EAAA,EAAiBA,EAAAsQ,EAAAhM,SAAgBtE,EAEjCyV,EAAApQ,KAAA,IAAAiL,EAAAoF,WAAA1V,IAEA,OAAAyV,EA36BAE,CAAA9C,GAAA+B,EAAAK,EAAA3Q,GAGA,SAAAsR,EAAAhB,EAAA/B,EAAAoC,EAAA3Q,GACA,OAAAkR,EAAAZ,EAAA/B,EAAAoC,EAAA3Q,GAGA,SAAAuR,EAAAjB,EAAA/B,EAAAoC,EAAA3Q,GACA,OAAAiR,EAAAtB,EAAApB,GAAA+B,EAAAK,EAAA3Q,GAGA,SAAAwR,EAAAlB,EAAA/B,EAAAoC,EAAA3Q,GACA,OAAAiR,EAk6BA,SAAAjF,EAAAyF,GAGA,IAFA,IAAA1V,EAAA2V,EAAAC,EACAR,EAAA,GACAzV,EAAA,EAAiBA,EAAAsQ,EAAAhM,WACjByR,GAAA,QADiC/V,EAGjCK,EAAAiQ,EAAAoF,WAAA1V,GACAgW,EAAA3V,GAAA,EACA4V,EAAA5V,EAAA,IACAoV,EAAApQ,KAAA4Q,GACAR,EAAApQ,KAAA2Q,GAGA,OAAAP,EA/6BAS,CAAArD,EAAA+B,EAAAtQ,OAAA2Q,GAAAL,EAAAK,EAAA3Q,GAkFA,SAAA6R,EAAAvB,EAAA1F,EAAAkH,GACA,WAAAlH,GAAAkH,IAAAxB,EAAAtQ,OACAiN,EAAA8E,cAAAzB,GAEArD,EAAA8E,cAAAzB,EAAAnO,MAAAyI,EAAAkH,IAIA,SAAAE,EAAA1B,EAAA1F,EAAAkH,GACAA,EAAAnS,KAAAiK,IAAA0G,EAAAtQ,OAAA8R,GAIA,IAHA,IAAAG,EAAA,GAEAvW,EAAAkP,EACAlP,EAAAoW,GAAA,CACA,IAQAI,EAAAC,EAAAC,EAAAC,EARAC,EAAAhC,EAAA5U,GACA6W,EAAA,KACAC,EAAAF,EAAA,MACAA,EAAA,MACAA,EAAA,MACA,EAEA,GAAA5W,EAAA8W,GAAAV,EAGA,OAAAU,GACA,OACAF,EAAA,MACAC,EAAAD,GAEA,MACA,OAEA,WADAJ,EAAA5B,EAAA5U,EAAA,OAEA2W,GAAA,GAAAC,IAAA,KAAAJ,GACA,MACAK,EAAAF,GAGA,MACA,OACAH,EAAA5B,EAAA5U,EAAA,GACAyW,EAAA7B,EAAA5U,EAAA,GACA,UAAAwW,IAAA,UAAAC,KACAE,GAAA,GAAAC,IAAA,OAAAJ,IAAA,KAAAC,GACA,OAAAE,EAAA,OAAAA,EAAA,SACAE,EAAAF,GAGA,MACA,OACAH,EAAA5B,EAAA5U,EAAA,GACAyW,EAAA7B,EAAA5U,EAAA,GACA0W,EAAA9B,EAAA5U,EAAA,GACA,UAAAwW,IAAA,UAAAC,IAAA,UAAAC,KACAC,GAAA,GAAAC,IAAA,OAAAJ,IAAA,OAAAC,IAAA,KAAAC,GACA,OAAAC,EAAA,UACAE,EAAAF,GAMA,OAAAE,GAGAA,EAAA,MACAC,EAAA,GACKD,EAAA,QAELA,GAAA,MACAN,EAAAlR,KAAAwR,IAAA,eACAA,EAAA,WAAAA,GAGAN,EAAAlR,KAAAwR,GACA7W,GAAA8W,EAGA,OAQA,SAAAC,GACA,IAAA1D,EAAA0D,EAAAzS,OACA,GAAA+O,GAAA2D,EACA,OAAA1J,OAAA2J,aAAA3H,MAAAhC,OAAAyJ,GAIA,IAAAR,EAAA,GACAvW,EAAA,EACA,KAAAA,EAAAqT,GACAkD,GAAAjJ,OAAA2J,aAAA3H,MACAhC,OACAyJ,EAAAtQ,MAAAzG,KAAAgX,IAGA,OAAAT,EAvBAW,CAAAX,GA98BA/W,EAAAmS,SACAnS,EAAA2X,WAoTA,SAAA7S,IACAA,OACAA,EAAA,GAEA,OAAAqN,EAAAyF,OAAA9S,IAvTA9E,EAAA6X,kBAAA,GA0BA1F,EAAAC,yBAAAnP,IAAA6O,EAAAM,oBACAN,EAAAM,oBAQA,WACA,IACA,IAAAxN,EAAA,IAAA4N,WAAA,GAEA,OADA5N,EAAA6N,UAAA,CAAqBA,UAAAD,WAAApQ,UAAA0V,IAAA,WAAmD,YACxE,KAAAlT,EAAAkT,OACA,mBAAAlT,EAAAmT,UACA,IAAAnT,EAAAmT,SAAA,KAAA7E,WACG,MAAAzE,GACH,UAfAuJ,GAKAhY,EAAAkS,eAkEAC,EAAA8F,SAAA,KAGA9F,EAAA+F,SAAA,SAAAtT,GAEA,OADAA,EAAA6N,UAAAN,EAAA/P,UACAwC,GA2BAuN,EAAAU,KAAA,SAAApR,EAAAkR,EAAA7N,GACA,OAAA+N,EAAA,KAAApR,EAAAkR,EAAA7N,IAGAqN,EAAAC,sBACAD,EAAA/P,UAAAqQ,UAAAD,WAAApQ,UACA+P,EAAAM,UAAAD,WACA,oBAAAjR,eAAA4W,SACAhG,EAAA5Q,OAAA4W,WAAAhG,GAEAjR,OAAAC,eAAAgR,EAAA5Q,OAAA4W,QAAA,CACA1W,MAAA,KACA2W,cAAA,KAiCAjG,EAAAyF,MAAA,SAAAvD,EAAAgE,EAAA/E,GACA,OArBA,SAAAhB,EAAA+B,EAAAgE,EAAA/E,GAEA,OADAc,EAAAC,GACAA,GAAA,EACAhC,EAAAC,EAAA+B,QAEApR,IAAAoV,EAIA,iBAAA/E,EACAjB,EAAAC,EAAA+B,GAAAgE,OAAA/E,GACAjB,EAAAC,EAAA+B,GAAAgE,QAEAhG,EAAAC,EAAA+B,GAQAuD,CAAA,KAAAvD,EAAAgE,EAAA/E,IAiBAnB,EAAAS,YAAA,SAAAyB,GACA,OAAAzB,EAAA,KAAAyB,IAKAlC,EAAAmG,gBAAA,SAAAjE,GACA,OAAAzB,EAAA,KAAAyB,IAiHAlC,EAAAyB,SAAA,SAAArO,GACA,cAAAA,MAAAgT,YAGApG,EAAAlH,QAAA,SAAA3F,EAAAC,GACA,IAAA4M,EAAAyB,SAAAtO,KAAA6M,EAAAyB,SAAArO,GACA,UAAAuN,UAAA,6BAGA,GAAAxN,IAAAC,EAAA,SAKA,IAHA,IAAAN,EAAAK,EAAAR,OACAiC,EAAAxB,EAAAT,OAEAtE,EAAA,EAAAqT,EAAApP,KAAAiK,IAAAzJ,EAAA8B,GAAuCvG,EAAAqT,IAASrT,EAChD,GAAA8E,EAAA9E,KAAA+E,EAAA/E,GAAA,CACAyE,EAAAK,EAAA9E,GACAuG,EAAAxB,EAAA/E,GACA,MAIA,OAAAyE,EAAA8B,GAAA,EACAA,EAAA9B,EAAA,EACA,GAGAkN,EAAAoB,WAAA,SAAAD,GACA,OAAAxF,OAAAwF,GAAA/D,eACA,UACA,WACA,YACA,YACA,aACA,aACA,aACA,WACA,YACA,cACA,eACA,SACA,QACA,WAIA4C,EAAAtL,OAAA,SAAA2R,EAAA1T,GACA,IAAAmN,EAAAuG,GACA,UAAA1F,UAAA,+CAGA,OAAA0F,EAAA1T,OACA,OAAAqN,EAAAyF,MAAA,GAGA,IAAApX,EACA,QAAAyC,IAAA6B,EAEA,IADAA,EAAA,EACAtE,EAAA,EAAeA,EAAAgY,EAAA1T,SAAiBtE,EAChCsE,GAAA0T,EAAAhY,GAAAsE,OAIA,IAAAkP,EAAA7B,EAAAS,YAAA9N,GACA2T,EAAA,EACA,IAAAjY,EAAA,EAAaA,EAAAgY,EAAA1T,SAAiBtE,EAAA,CAC9B,IAAA4U,EAAAoD,EAAAhY,GACA,IAAA2R,EAAAyB,SAAAwB,GACA,UAAAtC,UAAA,+CAEAsC,EAAArB,KAAAC,EAAAyE,GACAA,GAAArD,EAAAtQ,OAEA,OAAAkP,GA8CA7B,EAAAe,aA0EAf,EAAA/P,UAAAmW,WAAA,EAQApG,EAAA/P,UAAAsW,OAAA,WACA,IAAA7E,EAAAzP,KAAAU,OACA,GAAA+O,EAAA,KACA,UAAAtB,WAAA,6CAEA,QAAA/R,EAAA,EAAiBA,EAAAqT,EAASrT,GAAA,EAC1BkU,EAAAtQ,KAAA5D,IAAA,GAEA,OAAA4D,MAGA+N,EAAA/P,UAAAuW,OAAA,WACA,IAAA9E,EAAAzP,KAAAU,OACA,GAAA+O,EAAA,KACA,UAAAtB,WAAA,6CAEA,QAAA/R,EAAA,EAAiBA,EAAAqT,EAASrT,GAAA,EAC1BkU,EAAAtQ,KAAA5D,IAAA,GACAkU,EAAAtQ,KAAA5D,EAAA,EAAAA,EAAA,GAEA,OAAA4D,MAGA+N,EAAA/P,UAAAwW,OAAA,WACA,IAAA/E,EAAAzP,KAAAU,OACA,GAAA+O,EAAA,KACA,UAAAtB,WAAA,6CAEA,QAAA/R,EAAA,EAAiBA,EAAAqT,EAASrT,GAAA,EAC1BkU,EAAAtQ,KAAA5D,IAAA,GACAkU,EAAAtQ,KAAA5D,EAAA,EAAAA,EAAA,GACAkU,EAAAtQ,KAAA5D,EAAA,EAAAA,EAAA,GACAkU,EAAAtQ,KAAA5D,EAAA,EAAAA,EAAA,GAEA,OAAA4D,MAGA+N,EAAA/P,UAAAQ,SAAA,WACA,IAAAkC,EAAA,EAAAV,KAAAU,OACA,WAAAA,EAAA,GACA,IAAA+T,UAAA/T,OAAAgS,EAAA1S,KAAA,EAAAU,GAxHA,SAAAwO,EAAA5D,EAAAkH,GACA,IAAArC,GAAA,EAcA,SALAtR,IAAAyM,KAAA,KACAA,EAAA,GAIAA,EAAAtL,KAAAU,OACA,SAOA,SAJA7B,IAAA2T,KAAAxS,KAAAU,UACA8R,EAAAxS,KAAAU,QAGA8R,GAAA,EACA,SAOA,IAHAA,KAAA,KACAlH,KAAA,GAGA,SAKA,IAFA4D,MAAA,UAGA,OAAAA,GACA,UACA,OAAAwF,EAAA1U,KAAAsL,EAAAkH,GAEA,WACA,YACA,OAAAE,EAAA1S,KAAAsL,EAAAkH,GAEA,YACA,OAAAmC,EAAA3U,KAAAsL,EAAAkH,GAEA,aACA,aACA,OAAAoC,EAAA5U,KAAAsL,EAAAkH,GAEA,aACA,OAAAD,EAAAvS,KAAAsL,EAAAkH,GAEA,WACA,YACA,cACA,eACA,OAAAqC,EAAA7U,KAAAsL,EAAAkH,GAEA,QACA,GAAArC,EAAA,UAAAzB,UAAA,qBAAAQ,GACAA,KAAA,IAAA/D,cACAgF,GAAA,IAwDAzE,MAAA1L,KAAAyU,YAGA1G,EAAA/P,UAAAqH,OAAA,SAAAlE,GACA,IAAA4M,EAAAyB,SAAArO,GAAA,UAAAuN,UAAA,6BACA,OAAA1O,OAAAmB,GACA,IAAA4M,EAAAlH,QAAA7G,KAAAmB,IAGA4M,EAAA/P,UAAA8W,QAAA,WACA,IAAApI,EAAA,GACA9J,EAAAhH,EAAA6X,kBAKA,OAJAzT,KAAAU,OAAA,IACAgM,EAAA1M,KAAAxB,SAAA,QAAAoE,GAAAmS,MAAA,SAAkD7I,KAAA,KAClDlM,KAAAU,OAAAkC,IAAA8J,GAAA,UAEA,WAAAA,EAAA,KAGAqB,EAAA/P,UAAA6I,QAAA,SAAAmO,EAAA1J,EAAAkH,EAAAyC,EAAAC,GACA,IAAAnH,EAAAyB,SAAAwF,GACA,UAAAtG,UAAA,6BAgBA,QAbA7P,IAAAyM,IACAA,EAAA,QAEAzM,IAAA2T,IACAA,EAAAwC,IAAAtU,OAAA,QAEA7B,IAAAoW,IACAA,EAAA,QAEApW,IAAAqW,IACAA,EAAAlV,KAAAU,QAGA4K,EAAA,GAAAkH,EAAAwC,EAAAtU,QAAAuU,EAAA,GAAAC,EAAAlV,KAAAU,OACA,UAAAyN,WAAA,sBAGA,GAAA8G,GAAAC,GAAA5J,GAAAkH,EACA,SAEA,GAAAyC,GAAAC,EACA,SAEA,GAAA5J,GAAAkH,EACA,SAQA,GAAAxS,OAAAgV,EAAA,SASA,IAPA,IAAAnU,GAJAqU,KAAA,IADAD,KAAA,GAMAtS,GAPA6P,KAAA,IADAlH,KAAA,GASAmE,EAAApP,KAAAiK,IAAAzJ,EAAA8B,GAEAwS,EAAAnV,KAAA6C,MAAAoS,EAAAC,GACAE,EAAAJ,EAAAnS,MAAAyI,EAAAkH,GAEApW,EAAA,EAAiBA,EAAAqT,IAASrT,EAC1B,GAAA+Y,EAAA/Y,KAAAgZ,EAAAhZ,GAAA,CACAyE,EAAAsU,EAAA/Y,GACAuG,EAAAyS,EAAAhZ,GACA,MAIA,OAAAyE,EAAA8B,GAAA,EACAA,EAAA9B,EAAA,EACA,GA6HAkN,EAAA/P,UAAAqX,SAAA,SAAA7J,EAAAqD,EAAAK,GACA,WAAAlP,KAAAsM,QAAAd,EAAAqD,EAAAK,IAGAnB,EAAA/P,UAAAsO,QAAA,SAAAd,EAAAqD,EAAAK,GACA,OAAAqB,EAAAvQ,KAAAwL,EAAAqD,EAAAK,GAAA,IAGAnB,EAAA/P,UAAA2S,YAAA,SAAAnF,EAAAqD,EAAAK,GACA,OAAAqB,EAAAvQ,KAAAwL,EAAAqD,EAAAK,GAAA,IAkDAnB,EAAA/P,UAAAqR,MAAA,SAAAJ,EAAAoC,EAAA3Q,EAAAwO,GAEA,QAAArQ,IAAAwS,EACAnC,EAAA,OACAxO,EAAAV,KAAAU,OACA2Q,EAAA,OAEG,QAAAxS,IAAA6B,GAAA,iBAAA2Q,EACHnC,EAAAmC,EACA3Q,EAAAV,KAAAU,OACA2Q,EAAA,MAEG,KAAAiE,SAAAjE,GAWH,UAAAzM,MACA,2EAXAyM,GAAA,EACAiE,SAAA5U,IACAA,GAAA,OACA7B,IAAAqQ,MAAA,UAEAA,EAAAxO,EACAA,OAAA7B,GASA,IAAAyS,EAAAtR,KAAAU,OAAA2Q,EAGA,SAFAxS,IAAA6B,KAAA4Q,KAAA5Q,EAAA4Q,GAEArC,EAAAvO,OAAA,IAAAA,EAAA,GAAA2Q,EAAA,IAAAA,EAAArR,KAAAU,OACA,UAAAyN,WAAA,0CAGAe,MAAA,QAGA,IADA,IAAAiB,GAAA,IAEA,OAAAjB,GACA,UACA,OAAAkC,EAAApR,KAAAiP,EAAAoC,EAAA3Q,GAEA,WACA,YACA,OAAAgR,EAAA1R,KAAAiP,EAAAoC,EAAA3Q,GAEA,YACA,OAAAkR,EAAA5R,KAAAiP,EAAAoC,EAAA3Q,GAEA,aACA,aACA,OAAAsR,EAAAhS,KAAAiP,EAAAoC,EAAA3Q,GAEA,aAEA,OAAAuR,EAAAjS,KAAAiP,EAAAoC,EAAA3Q,GAEA,WACA,YACA,cACA,eACA,OAAAwR,EAAAlS,KAAAiP,EAAAoC,EAAA3Q,GAEA,QACA,GAAAyP,EAAA,UAAAzB,UAAA,qBAAAQ,GACAA,GAAA,GAAAA,GAAA/D,cACAgF,GAAA,IAKApC,EAAA/P,UAAA2O,OAAA,WACA,OACAkD,KAAA,SACAC,KAAAhP,MAAA9C,UAAA6E,MAAAtG,KAAAyD,KAAAuV,MAAAvV,KAAA,KAwFA,IAAAoT,EAAA,KAoBA,SAAAuB,EAAA3D,EAAA1F,EAAAkH,GACA,IAAAgD,EAAA,GACAhD,EAAAnS,KAAAiK,IAAA0G,EAAAtQ,OAAA8R,GAEA,QAAApW,EAAAkP,EAAqBlP,EAAAoW,IAASpW,EAC9BoZ,GAAA9L,OAAA2J,aAAA,IAAArC,EAAA5U,IAEA,OAAAoZ,EAGA,SAAAZ,EAAA5D,EAAA1F,EAAAkH,GACA,IAAAgD,EAAA,GACAhD,EAAAnS,KAAAiK,IAAA0G,EAAAtQ,OAAA8R,GAEA,QAAApW,EAAAkP,EAAqBlP,EAAAoW,IAASpW,EAC9BoZ,GAAA9L,OAAA2J,aAAArC,EAAA5U,IAEA,OAAAoZ,EAGA,SAAAd,EAAA1D,EAAA1F,EAAAkH,GACA,IAAA/C,EAAAuB,EAAAtQ,SAEA4K,KAAA,KAAAA,EAAA,KACAkH,KAAA,GAAAA,EAAA/C,KAAA+C,EAAA/C,GAGA,IADA,IAAA1D,EAAA,GACA3P,EAAAkP,EAAqBlP,EAAAoW,IAASpW,EAC9B2P,GAAA0J,EAAAzE,EAAA5U,IAEA,OAAA2P,EAGA,SAAA8I,EAAA7D,EAAA1F,EAAAkH,GAGA,IAFA,IAAAkD,EAAA1E,EAAAnO,MAAAyI,EAAAkH,GACAG,EAAA,GACAvW,EAAA,EAAiBA,EAAAsZ,EAAAhV,OAAkBtE,GAAA,EACnCuW,GAAAjJ,OAAA2J,aAAAqC,EAAAtZ,GAAA,IAAAsZ,EAAAtZ,EAAA,IAEA,OAAAuW,EA0CA,SAAAgD,EAAAtE,EAAAuE,EAAAlV,GACA,GAAA2Q,EAAA,MAAAA,EAAA,YAAAlD,WAAA,sBACA,GAAAkD,EAAAuE,EAAAlV,EAAA,UAAAyN,WAAA,yCA+JA,SAAA0H,EAAA7E,EAAA3T,EAAAgU,EAAAuE,EAAAhT,EAAA0H,GACA,IAAAyD,EAAAyB,SAAAwB,GAAA,UAAAtC,UAAA,+CACA,GAAArR,EAAAuF,GAAAvF,EAAAiN,EAAA,UAAA6D,WAAA,qCACA,GAAAkD,EAAAuE,EAAA5E,EAAAtQ,OAAA,UAAAyN,WAAA,sBAkDA,SAAA2H,EAAA9E,EAAA3T,EAAAgU,EAAA0E,GACA1Y,EAAA,IAAAA,EAAA,MAAAA,EAAA,GACA,QAAAjB,EAAA,EAAAkG,EAAAjC,KAAAiK,IAAA0G,EAAAtQ,OAAA2Q,EAAA,GAAuDjV,EAAAkG,IAAOlG,EAC9D4U,EAAAK,EAAAjV,IAAAiB,EAAA,QAAA0Y,EAAA3Z,EAAA,EAAAA,MACA,GAAA2Z,EAAA3Z,EAAA,EAAAA,GA8BA,SAAA4Z,EAAAhF,EAAA3T,EAAAgU,EAAA0E,GACA1Y,EAAA,IAAAA,EAAA,WAAAA,EAAA,GACA,QAAAjB,EAAA,EAAAkG,EAAAjC,KAAAiK,IAAA0G,EAAAtQ,OAAA2Q,EAAA,GAAuDjV,EAAAkG,IAAOlG,EAC9D4U,EAAAK,EAAAjV,GAAAiB,IAAA,GAAA0Y,EAAA3Z,EAAA,EAAAA,GAAA,IAmJA,SAAA6Z,EAAAjF,EAAA3T,EAAAgU,EAAAuE,EAAAhT,EAAA0H,GACA,GAAA+G,EAAAuE,EAAA5E,EAAAtQ,OAAA,UAAAyN,WAAA,sBACA,GAAAkD,EAAA,YAAAlD,WAAA,sBAGA,SAAA+H,EAAAlF,EAAA3T,EAAAgU,EAAA0E,EAAAI,GAKA,OAJAA,GACAF,EAAAjF,EAAA3T,EAAAgU,EAAA,GAEAzD,EAAAyB,MAAA2B,EAAA3T,EAAAgU,EAAA0E,EAAA,MACA1E,EAAA,EAWA,SAAA+E,EAAApF,EAAA3T,EAAAgU,EAAA0E,EAAAI,GAKA,OAJAA,GACAF,EAAAjF,EAAA3T,EAAAgU,EAAA,GAEAzD,EAAAyB,MAAA2B,EAAA3T,EAAAgU,EAAA0E,EAAA,MACA1E,EAAA,EA/cAtD,EAAA/P,UAAA6E,MAAA,SAAAyI,EAAAkH,GACA,IAoBA6D,EApBA5G,EAAAzP,KAAAU,OAqBA,IApBA4K,OAGA,GACAA,GAAAmE,GACA,IAAAnE,EAAA,GACGA,EAAAmE,IACHnE,EAAAmE,IANA+C,OAAA3T,IAAA2T,EAAA/C,IAAA+C,GASA,GACAA,GAAA/C,GACA,IAAA+C,EAAA,GACGA,EAAA/C,IACH+C,EAAA/C,GAGA+C,EAAAlH,IAAAkH,EAAAlH,GAGAyC,EAAAC,qBACAqI,EAAArW,KAAA2T,SAAArI,EAAAkH,IACAnE,UAAAN,EAAA/P,cACG,CACH,IAAAsY,EAAA9D,EAAAlH,EACA+K,EAAA,IAAAtI,EAAAuI,OAAAzX,GACA,QAAAzC,EAAA,EAAmBA,EAAAka,IAAcla,EACjCia,EAAAja,GAAA4D,KAAA5D,EAAAkP,GAIA,OAAA+K,GAWAtI,EAAA/P,UAAAuY,WAAA,SAAAlF,EAAAvC,EAAAqH,GACA9E,GAAA,EACAvC,GAAA,EACAqH,GAAAR,EAAAtE,EAAAvC,EAAA9O,KAAAU,QAKA,IAHA,IAAA8K,EAAAxL,KAAAqR,GACAmF,EAAA,EACApa,EAAA,IACAA,EAAA0S,IAAA0H,GAAA,MACAhL,GAAAxL,KAAAqR,EAAAjV,GAAAoa,EAGA,OAAAhL,GAGAuC,EAAA/P,UAAAyY,WAAA,SAAApF,EAAAvC,EAAAqH,GACA9E,GAAA,EACAvC,GAAA,EACAqH,GACAR,EAAAtE,EAAAvC,EAAA9O,KAAAU,QAKA,IAFA,IAAA8K,EAAAxL,KAAAqR,IAAAvC,GACA0H,EAAA,EACA1H,EAAA,IAAA0H,GAAA,MACAhL,GAAAxL,KAAAqR,IAAAvC,GAAA0H,EAGA,OAAAhL,GAGAuC,EAAA/P,UAAA0Y,UAAA,SAAArF,EAAA8E,GAEA,OADAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACAV,KAAAqR,IAGAtD,EAAA/P,UAAA2Y,aAAA,SAAAtF,EAAA8E,GAEA,OADAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACAV,KAAAqR,GAAArR,KAAAqR,EAAA,OAGAtD,EAAA/P,UAAAiT,aAAA,SAAAI,EAAA8E,GAEA,OADAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACAV,KAAAqR,IAAA,EAAArR,KAAAqR,EAAA,IAGAtD,EAAA/P,UAAA4Y,aAAA,SAAAvF,EAAA8E,GAGA,OAFAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,SAEAV,KAAAqR,GACArR,KAAAqR,EAAA,MACArR,KAAAqR,EAAA,QACA,SAAArR,KAAAqR,EAAA,IAGAtD,EAAA/P,UAAA6Y,aAAA,SAAAxF,EAAA8E,GAGA,OAFAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QAEA,SAAAV,KAAAqR,IACArR,KAAAqR,EAAA,OACArR,KAAAqR,EAAA,MACArR,KAAAqR,EAAA,KAGAtD,EAAA/P,UAAA8Y,UAAA,SAAAzF,EAAAvC,EAAAqH,GACA9E,GAAA,EACAvC,GAAA,EACAqH,GAAAR,EAAAtE,EAAAvC,EAAA9O,KAAAU,QAKA,IAHA,IAAA8K,EAAAxL,KAAAqR,GACAmF,EAAA,EACApa,EAAA,IACAA,EAAA0S,IAAA0H,GAAA,MACAhL,GAAAxL,KAAAqR,EAAAjV,GAAAoa,EAMA,OAFAhL,IAFAgL,GAAA,OAEAhL,GAAAnL,KAAAf,IAAA,IAAAwP,IAEAtD,GAGAuC,EAAA/P,UAAA+Y,UAAA,SAAA1F,EAAAvC,EAAAqH,GACA9E,GAAA,EACAvC,GAAA,EACAqH,GAAAR,EAAAtE,EAAAvC,EAAA9O,KAAAU,QAKA,IAHA,IAAAtE,EAAA0S,EACA0H,EAAA,EACAhL,EAAAxL,KAAAqR,IAAAjV,GACAA,EAAA,IAAAoa,GAAA,MACAhL,GAAAxL,KAAAqR,IAAAjV,GAAAoa,EAMA,OAFAhL,IAFAgL,GAAA,OAEAhL,GAAAnL,KAAAf,IAAA,IAAAwP,IAEAtD,GAGAuC,EAAA/P,UAAAgZ,SAAA,SAAA3F,EAAA8E,GAEA,OADAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACA,IAAAV,KAAAqR,IACA,OAAArR,KAAAqR,GAAA,GADArR,KAAAqR,IAIAtD,EAAA/P,UAAAiZ,YAAA,SAAA5F,EAAA8E,GACAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACA,IAAA8K,EAAAxL,KAAAqR,GAAArR,KAAAqR,EAAA,MACA,aAAA7F,EAAA,WAAAA,KAGAuC,EAAA/P,UAAAkZ,YAAA,SAAA7F,EAAA8E,GACAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACA,IAAA8K,EAAAxL,KAAAqR,EAAA,GAAArR,KAAAqR,IAAA,EACA,aAAA7F,EAAA,WAAAA,KAGAuC,EAAA/P,UAAAmZ,YAAA,SAAA9F,EAAA8E,GAGA,OAFAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QAEAV,KAAAqR,GACArR,KAAAqR,EAAA,MACArR,KAAAqR,EAAA,OACArR,KAAAqR,EAAA,QAGAtD,EAAA/P,UAAAoZ,YAAA,SAAA/F,EAAA8E,GAGA,OAFAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QAEAV,KAAAqR,IAAA,GACArR,KAAAqR,EAAA,OACArR,KAAAqR,EAAA,MACArR,KAAAqR,EAAA,IAGAtD,EAAA/P,UAAAqZ,YAAA,SAAAhG,EAAA8E,GAEA,OADAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACAkN,EAAAmD,KAAA/Q,KAAAqR,GAAA,SAGAtD,EAAA/P,UAAAsZ,YAAA,SAAAjG,EAAA8E,GAEA,OADAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACAkN,EAAAmD,KAAA/Q,KAAAqR,GAAA,SAGAtD,EAAA/P,UAAAuZ,aAAA,SAAAlG,EAAA8E,GAEA,OADAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACAkN,EAAAmD,KAAA/Q,KAAAqR,GAAA,SAGAtD,EAAA/P,UAAAwZ,aAAA,SAAAnG,EAAA8E,GAEA,OADAA,GAAAR,EAAAtE,EAAA,EAAArR,KAAAU,QACAkN,EAAAmD,KAAA/Q,KAAAqR,GAAA,SASAtD,EAAA/P,UAAAyZ,YAAA,SAAApa,EAAAgU,EAAAvC,EAAAqH,IACA9Y,KACAgU,GAAA,EACAvC,GAAA,EACAqH,IAEAN,EAAA7V,KAAA3C,EAAAgU,EAAAvC,EADAzO,KAAAf,IAAA,IAAAwP,GAAA,EACA,GAGA,IAAA0H,EAAA,EACApa,EAAA,EAEA,IADA4D,KAAAqR,GAAA,IAAAhU,IACAjB,EAAA0S,IAAA0H,GAAA,MACAxW,KAAAqR,EAAAjV,GAAAiB,EAAAmZ,EAAA,IAGA,OAAAnF,EAAAvC,GAGAf,EAAA/P,UAAA0Z,YAAA,SAAAra,EAAAgU,EAAAvC,EAAAqH,IACA9Y,KACAgU,GAAA,EACAvC,GAAA,EACAqH,IAEAN,EAAA7V,KAAA3C,EAAAgU,EAAAvC,EADAzO,KAAAf,IAAA,IAAAwP,GAAA,EACA,GAGA,IAAA1S,EAAA0S,EAAA,EACA0H,EAAA,EAEA,IADAxW,KAAAqR,EAAAjV,GAAA,IAAAiB,IACAjB,GAAA,IAAAoa,GAAA,MACAxW,KAAAqR,EAAAjV,GAAAiB,EAAAmZ,EAAA,IAGA,OAAAnF,EAAAvC,GAGAf,EAAA/P,UAAA2Z,WAAA,SAAAta,EAAAgU,EAAA8E,GAMA,OALA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,SACAtD,EAAAC,sBAAA3Q,EAAAgD,KAAAC,MAAAjD,IACA2C,KAAAqR,GAAA,IAAAhU,EACAgU,EAAA,GAWAtD,EAAA/P,UAAA4Z,cAAA,SAAAva,EAAAgU,EAAA8E,GAUA,OATA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,WACAtD,EAAAC,qBACAhO,KAAAqR,GAAA,IAAAhU,EACA2C,KAAAqR,EAAA,GAAAhU,IAAA,GAEAyY,EAAA9V,KAAA3C,EAAAgU,GAAA,GAEAA,EAAA,GAGAtD,EAAA/P,UAAA6Z,cAAA,SAAAxa,EAAAgU,EAAA8E,GAUA,OATA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,WACAtD,EAAAC,qBACAhO,KAAAqR,GAAAhU,IAAA,EACA2C,KAAAqR,EAAA,OAAAhU,GAEAyY,EAAA9V,KAAA3C,EAAAgU,GAAA,GAEAA,EAAA,GAUAtD,EAAA/P,UAAA8Z,cAAA,SAAAza,EAAAgU,EAAA8E,GAYA,OAXA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,gBACAtD,EAAAC,qBACAhO,KAAAqR,EAAA,GAAAhU,IAAA,GACA2C,KAAAqR,EAAA,GAAAhU,IAAA,GACA2C,KAAAqR,EAAA,GAAAhU,IAAA,EACA2C,KAAAqR,GAAA,IAAAhU,GAEA2Y,EAAAhW,KAAA3C,EAAAgU,GAAA,GAEAA,EAAA,GAGAtD,EAAA/P,UAAA+Z,cAAA,SAAA1a,EAAAgU,EAAA8E,GAYA,OAXA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,gBACAtD,EAAAC,qBACAhO,KAAAqR,GAAAhU,IAAA,GACA2C,KAAAqR,EAAA,GAAAhU,IAAA,GACA2C,KAAAqR,EAAA,GAAAhU,IAAA,EACA2C,KAAAqR,EAAA,OAAAhU,GAEA2Y,EAAAhW,KAAA3C,EAAAgU,GAAA,GAEAA,EAAA,GAGAtD,EAAA/P,UAAAga,WAAA,SAAA3a,EAAAgU,EAAAvC,EAAAqH,GAGA,GAFA9Y,KACAgU,GAAA,GACA8E,EAAA,CACA,IAAA8B,EAAA5X,KAAAf,IAAA,IAAAwP,EAAA,GAEA+G,EAAA7V,KAAA3C,EAAAgU,EAAAvC,EAAAmJ,EAAA,GAAAA,GAGA,IAAA7b,EAAA,EACAoa,EAAA,EACA0B,EAAA,EAEA,IADAlY,KAAAqR,GAAA,IAAAhU,IACAjB,EAAA0S,IAAA0H,GAAA,MACAnZ,EAAA,OAAA6a,GAAA,IAAAlY,KAAAqR,EAAAjV,EAAA,KACA8b,EAAA,GAEAlY,KAAAqR,EAAAjV,IAAAiB,EAAAmZ,GAAA,GAAA0B,EAAA,IAGA,OAAA7G,EAAAvC,GAGAf,EAAA/P,UAAAma,WAAA,SAAA9a,EAAAgU,EAAAvC,EAAAqH,GAGA,GAFA9Y,KACAgU,GAAA,GACA8E,EAAA,CACA,IAAA8B,EAAA5X,KAAAf,IAAA,IAAAwP,EAAA,GAEA+G,EAAA7V,KAAA3C,EAAAgU,EAAAvC,EAAAmJ,EAAA,GAAAA,GAGA,IAAA7b,EAAA0S,EAAA,EACA0H,EAAA,EACA0B,EAAA,EAEA,IADAlY,KAAAqR,EAAAjV,GAAA,IAAAiB,IACAjB,GAAA,IAAAoa,GAAA,MACAnZ,EAAA,OAAA6a,GAAA,IAAAlY,KAAAqR,EAAAjV,EAAA,KACA8b,EAAA,GAEAlY,KAAAqR,EAAAjV,IAAAiB,EAAAmZ,GAAA,GAAA0B,EAAA,IAGA,OAAA7G,EAAAvC,GAGAf,EAAA/P,UAAAoa,UAAA,SAAA/a,EAAAgU,EAAA8E,GAOA,OANA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,YACAtD,EAAAC,sBAAA3Q,EAAAgD,KAAAC,MAAAjD,IACAA,EAAA,IAAAA,EAAA,IAAAA,EAAA,GACA2C,KAAAqR,GAAA,IAAAhU,EACAgU,EAAA,GAGAtD,EAAA/P,UAAAqa,aAAA,SAAAhb,EAAAgU,EAAA8E,GAUA,OATA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,gBACAtD,EAAAC,qBACAhO,KAAAqR,GAAA,IAAAhU,EACA2C,KAAAqR,EAAA,GAAAhU,IAAA,GAEAyY,EAAA9V,KAAA3C,EAAAgU,GAAA,GAEAA,EAAA,GAGAtD,EAAA/P,UAAAsa,aAAA,SAAAjb,EAAAgU,EAAA8E,GAUA,OATA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,gBACAtD,EAAAC,qBACAhO,KAAAqR,GAAAhU,IAAA,EACA2C,KAAAqR,EAAA,OAAAhU,GAEAyY,EAAA9V,KAAA3C,EAAAgU,GAAA,GAEAA,EAAA,GAGAtD,EAAA/P,UAAAua,aAAA,SAAAlb,EAAAgU,EAAA8E,GAYA,OAXA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,0BACAtD,EAAAC,qBACAhO,KAAAqR,GAAA,IAAAhU,EACA2C,KAAAqR,EAAA,GAAAhU,IAAA,EACA2C,KAAAqR,EAAA,GAAAhU,IAAA,GACA2C,KAAAqR,EAAA,GAAAhU,IAAA,IAEA2Y,EAAAhW,KAAA3C,EAAAgU,GAAA,GAEAA,EAAA,GAGAtD,EAAA/P,UAAAwa,aAAA,SAAAnb,EAAAgU,EAAA8E,GAaA,OAZA9Y,KACAgU,GAAA,EACA8E,GAAAN,EAAA7V,KAAA3C,EAAAgU,EAAA,0BACAhU,EAAA,IAAAA,EAAA,WAAAA,EAAA,GACA0Q,EAAAC,qBACAhO,KAAAqR,GAAAhU,IAAA,GACA2C,KAAAqR,EAAA,GAAAhU,IAAA,GACA2C,KAAAqR,EAAA,GAAAhU,IAAA,EACA2C,KAAAqR,EAAA,OAAAhU,GAEA2Y,EAAAhW,KAAA3C,EAAAgU,GAAA,GAEAA,EAAA,GAgBAtD,EAAA/P,UAAAya,aAAA,SAAApb,EAAAgU,EAAA8E,GACA,OAAAD,EAAAlW,KAAA3C,EAAAgU,GAAA,EAAA8E,IAGApI,EAAA/P,UAAA0a,aAAA,SAAArb,EAAAgU,EAAA8E,GACA,OAAAD,EAAAlW,KAAA3C,EAAAgU,GAAA,EAAA8E,IAWApI,EAAA/P,UAAA2a,cAAA,SAAAtb,EAAAgU,EAAA8E,GACA,OAAAC,EAAApW,KAAA3C,EAAAgU,GAAA,EAAA8E,IAGApI,EAAA/P,UAAA4a,cAAA,SAAAvb,EAAAgU,EAAA8E,GACA,OAAAC,EAAApW,KAAA3C,EAAAgU,GAAA,EAAA8E,IAIApI,EAAA/P,UAAA2R,KAAA,SAAAqF,EAAA6D,EAAAvN,EAAAkH,GAQA,GAPAlH,MAAA,GACAkH,GAAA,IAAAA,MAAAxS,KAAAU,QACAmY,GAAA7D,EAAAtU,SAAAmY,EAAA7D,EAAAtU,QACAmY,MAAA,GACArG,EAAA,GAAAA,EAAAlH,IAAAkH,EAAAlH,GAGAkH,IAAAlH,EAAA,SACA,OAAA0J,EAAAtU,QAAA,IAAAV,KAAAU,OAAA,SAGA,GAAAmY,EAAA,EACA,UAAA1K,WAAA,6BAEA,GAAA7C,EAAA,GAAAA,GAAAtL,KAAAU,OAAA,UAAAyN,WAAA,6BACA,GAAAqE,EAAA,YAAArE,WAAA,2BAGAqE,EAAAxS,KAAAU,SAAA8R,EAAAxS,KAAAU,QACAsU,EAAAtU,OAAAmY,EAAArG,EAAAlH,IACAkH,EAAAwC,EAAAtU,OAAAmY,EAAAvN,GAGA,IACAlP,EADAqT,EAAA+C,EAAAlH,EAGA,GAAAtL,OAAAgV,GAAA1J,EAAAuN,KAAArG,EAEA,IAAApW,EAAAqT,EAAA,EAAqBrT,GAAA,IAAQA,EAC7B4Y,EAAA5Y,EAAAyc,GAAA7Y,KAAA5D,EAAAkP,QAEG,GAAAmE,EAAA,MAAA1B,EAAAC,oBAEH,IAAA5R,EAAA,EAAeA,EAAAqT,IAASrT,EACxB4Y,EAAA5Y,EAAAyc,GAAA7Y,KAAA5D,EAAAkP,QAGA8C,WAAApQ,UAAA8a,IAAAvc,KACAyY,EACAhV,KAAA2T,SAAArI,IAAAmE,GACAoJ,GAIA,OAAApJ,GAOA1B,EAAA/P,UAAAiW,KAAA,SAAAzI,EAAAF,EAAAkH,EAAAtD,GAEA,oBAAA1D,EAAA,CASA,GARA,iBAAAF,GACA4D,EAAA5D,EACAA,EAAA,EACAkH,EAAAxS,KAAAU,QACK,iBAAA8R,IACLtD,EAAAsD,EACAA,EAAAxS,KAAAU,QAEA,IAAA8K,EAAA9K,OAAA,CACA,IAAAqY,EAAAvN,EAAAsG,WAAA,GACAiH,EAAA,MACAvN,EAAAuN,GAGA,QAAAla,IAAAqQ,GAAA,iBAAAA,EACA,UAAAR,UAAA,6BAEA,oBAAAQ,IAAAnB,EAAAoB,WAAAD,GACA,UAAAR,UAAA,qBAAAQ,OAEG,iBAAA1D,IACHA,GAAA,KAIA,GAAAF,EAAA,GAAAtL,KAAAU,OAAA4K,GAAAtL,KAAAU,OAAA8R,EACA,UAAArE,WAAA,sBAGA,GAAAqE,GAAAlH,EACA,OAAAtL,KAQA,IAAA5D,EACA,GANAkP,KAAA,EACAkH,OAAA3T,IAAA2T,EAAAxS,KAAAU,OAAA8R,IAAA,EAEAhH,MAAA,GAGA,iBAAAA,EACA,IAAApP,EAAAkP,EAAmBlP,EAAAoW,IAASpW,EAC5B4D,KAAA5D,GAAAoP,MAEG,CACH,IAAAkK,EAAA3H,EAAAyB,SAAAhE,GACAA,EACA4E,EAAA,IAAArC,EAAAvC,EAAA0D,GAAA1Q,YACAiR,EAAAiG,EAAAhV,OACA,IAAAtE,EAAA,EAAeA,EAAAoW,EAAAlH,IAAiBlP,EAChC4D,KAAA5D,EAAAkP,GAAAoK,EAAAtZ,EAAAqT,GAIA,OAAAzP,MAMA,IAAAgZ,EAAA,qBAmBA,SAAAvD,EAAA5X,GACA,OAAAA,EAAA,OAAAA,EAAAW,SAAA,IACAX,EAAAW,SAAA,IAGA,SAAA4R,EAAAnB,EAAAkD,GAEA,IAAAc,EADAd,KAAArL,IAMA,IAJA,IAAApG,EAAAuO,EAAAvO,OACAuY,EAAA,KACAvD,EAAA,GAEAtZ,EAAA,EAAiBA,EAAAsE,IAAYtE,EAAA,CAI7B,IAHA6W,EAAAhE,EAAA6C,WAAA1V,IAGA,OAAA6W,EAAA,OAEA,IAAAgG,EAAA,CAEA,GAAAhG,EAAA,QAEAd,GAAA,OAAAuD,EAAAjU,KAAA,aACA,SACS,GAAArF,EAAA,IAAAsE,EAAA,EAETyR,GAAA,OAAAuD,EAAAjU,KAAA,aACA,SAIAwX,EAAAhG,EAEA,SAIA,GAAAA,EAAA,QACAd,GAAA,OAAAuD,EAAAjU,KAAA,aACAwX,EAAAhG,EACA,SAIAA,EAAA,OAAAgG,EAAA,UAAAhG,EAAA,YACKgG,IAEL9G,GAAA,OAAAuD,EAAAjU,KAAA,aAMA,GAHAwX,EAAA,KAGAhG,EAAA,KACA,IAAAd,GAAA,WACAuD,EAAAjU,KAAAwR,QACK,GAAAA,EAAA,MACL,IAAAd,GAAA,WACAuD,EAAAjU,KACAwR,GAAA,MACA,GAAAA,EAAA,UAEK,GAAAA,EAAA,OACL,IAAAd,GAAA,WACAuD,EAAAjU,KACAwR,GAAA,OACAA,GAAA,SACA,GAAAA,EAAA,SAEK,MAAAA,EAAA,SASL,UAAArO,MAAA,sBARA,IAAAuN,GAAA,WACAuD,EAAAjU,KACAwR,GAAA,OACAA,GAAA,UACAA,GAAA,SACA,GAAAA,EAAA,MAOA,OAAAyC,EA4BA,SAAArF,EAAA3D,GACA,OAAAiB,EAAAuL,YAhIA,SAAAxM,GAIA,IAFAA,EAUA,SAAAA,GACA,OAAAA,EAAAjM,KAAAiM,EAAAjM,OACAiM,EAAAyM,QAAA,iBAZAC,CAAA1M,GAAAyM,QAAAH,EAAA,KAEAtY,OAAA,WAEA,KAAAgM,EAAAhM,OAAA,MACAgM,GAAA,IAEA,OAAAA,EAuHA2M,CAAA3M,IAGA,SAAAiF,EAAA2H,EAAAC,EAAAlI,EAAA3Q,GACA,QAAAtE,EAAA,EAAiBA,EAAAsE,KACjBtE,EAAAiV,GAAAkI,EAAA7Y,QAAAtE,GAAAkd,EAAA5Y,UAD6BtE,EAE7Bmd,EAAAnd,EAAAiV,GAAAiI,EAAAld,GAEA,OAAAA,qGCrvDA,MAAAgC,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAasd,EAMTxM,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,MAAQc,EAAAzO,QAAU2B,KAAKyN,OAGzDoC,WACI,OAAI7P,KAAKgM,KAAK6D,OAAS7P,KAAKyN,MAAMoC,KACvB7P,KAAKgM,KAAK6D,MACT7P,KAAKgM,KAAK6D,MAAQ7P,KAAKyN,MAAMoC,KAC9B7P,KAAKyN,MAAMoC,OACV7P,KAAKyN,MAAMoC,OAAQ7P,KAAKgM,KAAK6D,OAC9B7P,KAAKgM,KAAK6D,MAvB7BjU,EAAA4d,MA8BA5d,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAK/K,IAAIwM,IACnBrP,EAAUG,WAAWyN,IAASA,EAAKtF,SAC1CyG,EAAME,MAAM5L,KAAKgM,GACVrP,EAAUG,WAAWkP,IAAUA,EAAM/G,SAC5CyG,EAAME,MAAM5L,KAAKuK,GAEjBmB,EAAME,MAAM5L,KAAK,IAAI+X,EAAIxN,EAAMyB,qFC3CvC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAaud,EAOTzM,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,MAAQc,EAAAzO,QAAU2B,KAAKyN,QAf7D7R,EAAA6d,MAmBA7d,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAK9F,SAASuH,IAE9BrP,EAAUG,WAAWyN,IAASA,EAAKtF,UACnCtI,EAAUG,WAAWkP,IAAUA,EAAM/G,SAEtCyG,EAAME,MAAM5L,KAAKrD,EAAU,IAE3B+O,EAAME,MAAM5L,KAAK,IAAIgY,EAAIzN,EAAMyB,qFCjCvC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAawd,EAOT1M,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,MAAQc,EAAAzO,QAAU2B,KAAKyN,QAf7D7R,EAAA8d,MAmBA9d,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAKpK,SAAS6L,IAE/BN,EAAME,MAAM5L,KAAK,IAAIiY,EAAI1N,EAAMyB,qFC5BvC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAayd,EAOT3M,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,OAASc,EAAAzO,QAAU2B,KAAKyN,QAf9D7R,EAAA+d,MAmBA/d,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAKxJ,UAAUiL,IAEhCN,EAAME,MAAM5L,KAAK,IAAIkY,EAAI3N,EAAMyB,qFC5BvC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa0d,EAOT5M,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,OAASc,EAAAzO,QAAU2B,KAAKyN,QAf9D7R,EAAAge,MAmBAhe,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAKrC,WAAW8D,IAEjCN,EAAME,MAAM5L,KAAK,IAAImY,EAAI5N,EAAMyB,qFC5BvC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa2d,EAQT7M,YAAYhB,EAAWyB,EAAYqM,GAAiB,GAChD9Z,KAAKrD,KAAO,KACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EACbzN,KAAK8Z,MAAQA,EAGjB9M,WACI,OAAIhN,KAAK8Z,MACEhN,EAAAzO,QAAU2B,KAAKgM,MAAQ,OAASc,EAAAzO,QAAU2B,KAAKyN,OAE/CX,EAAAzO,QAAU2B,KAAKgM,MAAQ,MAAQc,EAAAzO,QAAU2B,KAAKyN,QApBjE7R,EAAAie,KAyBAje,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKrD,GAAiC,IAAvB4N,EAAKxG,OAAOiI,GAAkB,EAAI,IAE7DN,EAAME,MAAM5L,KAAK,IAAIoY,EAAG7N,EAAMyB,qFClCtC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa6d,EAQT/M,YAAYhB,EAAWyB,EAAYqM,GAAiB,GAChD9Z,KAAKrD,KAAO,KACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EACbzN,KAAK8Z,MAAQA,EAGjB9M,WACI,OAAIhN,KAAK8Z,MACEhN,EAAAzO,QAAU2B,KAAKgM,MAAQ,OAASc,EAAAzO,QAAU2B,KAAKyN,OAE/CX,EAAAzO,QAAU2B,KAAKgM,MAAQ,MAAQc,EAAAzO,QAAU2B,KAAKyN,QApBjE7R,EAAAme,KAyBAne,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKrD,GAAkC,IAAxB4N,EAAK7E,QAAQsG,GAAkB,EAAI,IAE9DN,EAAME,MAAM5L,KAAK,IAAIsY,EAAG/N,EAAMyB,qFClCtC,MAAArP,EAAAlC,EAAA,GACA8d,EAAA9d,EAAA,GACA4Q,EAAA5Q,EAAA,GAEM+d,EAAqB,CAAC3b,EAAW4b,KACnC,IAAK,MAAM9d,KAAKkC,EACZ,GAAIA,EAAKL,eAAe7B,GAAI,CACxB,GACuB,iBAAZkC,EAAKlC,IACK,iBAAjBkC,EAAKlC,GAAGO,MACRyB,EAAUG,WAAWD,EAAKlC,GAAG6Q,UAC/B,CACE,MAAMkN,EAAY7b,EAAKlC,GAAG6Q,SACrBrL,SAAS,GACTgE,OAAO,IACPpH,WACLF,EAAKlC,GAAGyT,KAAOqK,EAAMC,GAEF,iBAAZ7b,EAAKlC,IACZ6d,EAAmB3b,EAAKlC,GAAI8d,KAMtCE,EAAe9b,IACjB,MAAM+b,EAAU,GAChB,IAAK,MAAMje,KAAKkC,EACZ,GAAIA,EAAKL,eAAe7B,KAEG,iBAAZkC,EAAKlC,IACK,WAAjBkC,EAAKlC,GAAGO,MACR2B,EAAKlC,GAAGke,OACRhc,EAAKlC,GAAGke,MAAM5Z,OAAS,GAEvB2Z,EAAQ5Y,KAAKnD,EAAKlC,GAAGke,OAEF,iBAAZhc,EAAKlC,IAAiB,CAC7B,MAAMme,EAAmBH,EAAY9b,EAAKlC,IACtCme,EAAY7Z,OAAS,GACrB2Z,EAAQ5Y,QAAQ8Y,GAKhC,OAAOF,GAGX,MAAaG,EAWTxN,YAAYsN,EAAYG,EAAWC,GAqB/B,GApBA1a,KAAKrD,KAAO,WACZqD,KAAKya,KAAOA,EACZza,KAAK0a,QAAUA,EACf1a,KAAKsa,MAAQA,EACbta,KAAK2a,SAAU,EACf3a,KAAK4a,WAAa,SAClB5a,KAAK6a,UAAW,EAChB7a,KAAKqa,QAAU,GAEXra,KAAKsa,MAAM5Z,OAAS,GACpBV,KAAKsa,MAAM,aAAcQ,GACQ,WAAjC9a,KAAKsa,MAAM,GAAGS,UAAUpe,MACc,cAAtCqD,KAAKsa,MAAM,GAAGS,UAAUzc,KAAK3B,OAE7BqD,KAAK2a,SAAU,EACf3a,KAAKsa,MAAM9W,SAEW,IAAtBxD,KAAKsa,MAAM5Z,QAAuC,WAAvBV,KAAKsa,MAAM,GAAG3d,OACzCqD,KAAK6a,UAAW,GAEhB7a,KAAKya,QAAQT,EAAgB,CAC7B,MAAMgB,EAAgBhB,EAAuBha,KAAKya,MAAMrO,MAAM,KAAK,GAC7D6O,EAAiBjB,EAAuBha,KAAKya,MAC9CtB,QAAQ6B,EAAc,IACtBvJ,OAAO,GACP5O,MAAM,GAAI,GACVuJ,MAAM,MAEP6O,EAAcva,OAAS,GACG,IAAzBua,EAAcva,QAAqC,KAArBua,EAAc,KAE7Cjb,KAAKsa,MAAMY,QAAS5c,GAAc2b,EAAmB3b,EAAM2c,IAGnE,MAAMZ,EAAe,GACrBra,KAAKsa,MAAMY,QAAS5c,IAChB,MAAMic,EAAcH,EAAY9b,GAC5Bic,EAAY7Z,OAAS,GACrB2Z,EAAQ5Y,QAAQ8Y,KAIpBF,EAAQ3Z,OAAS,GACjB2Z,EAAQc,MACHC,GACGA,EAAW1a,SAAW2Z,EAAQ,GAAG3Z,QACjC0a,EAAWzP,IAAKrN,GAAcA,EAAKuR,MAAM3D,KAAK,MAC1CmO,EAAQ,GAAG1O,IAAKrN,GAAcA,EAAKuR,MAAM3D,KAAK,KAG1DmO,EAAQ,GAAGa,QAAS5c,IACZF,EAAUG,WAAWD,GACrB0B,KAAKqa,QAAQ5Y,KAAK,WACXnD,EAAKuR,KACZ7P,KAAKqa,QAAQ5Y,KAAKnD,EAAKuR,MAEvB7P,KAAKqa,QAAQ5Y,KAAK,aAGnB4Y,EAAQ3Z,OAAS,GACxBV,KAAKqa,QAAQ5Y,KAAK,cAxE9B7F,EAAA4e,mBA6EA,MAAaa,EAKTrO,YAAYsO,EAAuBpB,GAC/Bla,KAAKrD,KAAO,WACZqD,KAAKsb,MAAQA,EACbtb,KAAKka,MAAQA,GARrBte,EAAAyf,WAYA,MAAaP,EAMT9N,YAAY+N,GACR/a,KAAKrD,KAAO,UACZqD,KAAKvB,SAAU,EACfuB,KAAK+a,UAAYA,EAGrB/N,WACI,MAAO,WAAaF,EAAAzO,QAAU2B,KAAK+a,WAAa,MAbxDnf,EAAAkf,UAiBA,MAAaS,EAWTvO,YAAY+N,EAAgB9N,EAAeuO,EAAcC,EAAeC,GACpE1b,KAAKrD,KAAO,QACZqD,KAAKvB,SAAU,EACfuB,KAAK+a,UAAYA,EACjB/a,KAAKiN,SAAWA,EACZyO,EACA1b,KAAK2b,OAAQ,EACNH,GAAUC,GACjBzb,KAAK2b,OAAQ,EACb3b,KAAK4b,KAAOJ,EACZxb,KAAK6b,MAAQJ,EAETzb,KAAK4b,KAAKlb,QAAU,GACpBV,KAAK4b,KAAK,aAAcd,GACQ,WAAhC9a,KAAK4b,KAAK,GAAGb,UAAUpe,MACc,cAArCqD,KAAK4b,KAAK,GAAGb,UAAUzc,KAAK3B,MAE5BqD,KAAK2a,SAAU,EACf3a,KAAK4b,KAAKpY,SAEVxD,KAAK2a,SAAU,GAGnB3a,KAAK2b,OAAQ,EAIrB3O,WACI,OAAIhN,KAAK2b,OAAS3b,KAAK4b,MAAQ5b,KAAK6b,MACzB/O,EAAAzO,QAAU2B,KAAK+a,WACf/a,KAAK2b,MACL,KAAO7O,EAAAzO,QAAU2B,KAAK+a,WAAa,SAAWjO,EAAAzO,QAAU2B,KAAKiN,UAAY,KAEzE,mCA5CnBrR,EAAA2f,QAiDA3f,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM2O,EAAe3O,EAAME,MAAMC,MAC3ByO,EAAgB5O,EAAME,MAAMC,MAC5B0O,EAAU7O,EAAM8O,aACtB,GAAK7d,EAAUG,WAAWud,GAGnB,CACH,MAAMI,EAAmBF,EAAQG,KAAMtf,GAAWA,EAAEuf,KAAON,EAAa9T,cACxE,GAAKkU,GAA8C,aAA1BA,EAAiBvf,KAGnC,GAAIyB,EAAUG,WAAWwd,GAAgB,CAC5C,MAAMM,EAAYL,EAAQ1P,QAAQ4P,KAE9BG,GAAa,IACZN,EAAc1W,OAAO,IACpB6H,EAAOkP,GAAK,IAAMN,EAAa9T,eAAgBmF,EAAMmP,QAEvDnP,EAAMmP,MAAMpP,EAAOkP,GAAK,IAAMN,EAAa9T,eAAgB,EAC3DmF,EAAMiP,GAAKC,QAEZ,GACDnP,EAAOkP,GAAK,IAAMN,EAAa9T,eAAgBmF,EAAMmP,OAChC,QAAvBP,EAAcpf,KA2DX,GACDuQ,EAAOkP,GAAK,IAAMN,EAAa9T,eAAgBmF,EAAMmP,SAC9B,OAAvBP,EAAcpf,MACgB,iBAA5Bof,EAAc/P,KAAKrP,MACnByB,EAAUG,WAAWwd,EAActO,QACnCsO,EAActO,MAAMpI,OAAO,IACH,WAAvB0W,EAAcpf,MAAiD,iBAA5Bof,EAAczd,KAAK3B,MAoCxD,GAAMuQ,EAAOkP,GAAK,IAAMN,EAAa9T,eAAgBmF,EAAMmP,MA8B9DnP,EAAMoP,aAAa9a,KAAK,IAAI8Z,EAAMQ,EAAeD,EAAc,KAAM,MAAM,QA9BL,CACtE,MAAMO,EAAYL,EAAQ1P,QAAQ4P,GAElC,GADA/O,EAAMmP,MAAMpP,EAAOkP,GAAK,IAAMN,EAAa9T,eAAgB,EACvDqU,GAAa,EAAG,CAChBlP,EAAMqP,QAAS,EACf,MAAMC,EAAiBtP,EAAMuP,QAC7BD,EAAUL,GAAKC,EACf,MAAMM,EAAgBF,EAAUG,QAC1BC,EAAa1P,EAAMuP,QACzBG,EAAWT,GAAKjP,EAAMiP,GAAK,EAC3B,MAAMU,EAAsBD,EAAWD,QAER,IAA1BE,EAAepc,QACZ,SAAUoc,EAAe,IACG,WAA3BA,EAAe,GAAGngB,MACfmgB,EAAe,GAAGxC,OACiB,IAAnCwC,EAAe,GAAGxC,MAAM5Z,QACL,YAA3Boc,EAAe,GAAGngB,MAElBwQ,EAAMoP,aAAa9a,KAAK,IAAIqZ,EAAQiB,IACpC5O,EAAMoP,aAAa9a,QAAQkb,IAE3BxP,EAAMoP,aAAa9a,KACf,IAAI8Z,EAAMQ,EAAeD,EAAca,EAAeG,SAI9D3P,EAAMoP,aAAa9a,KAAK,IAAI8Z,EAAMQ,EAAeD,QA9DvD,CACE,MAAMO,EAAYL,EAAQ1P,QAAQ4P,GAClC,GAAIG,GAAa,EAAG,CAChBlP,EAAMqP,QAAS,EACf,MAAMC,EAAiBtP,EAAMuP,QAC7BD,EAAUL,GAAKC,EACf,MAAMM,EAAgBF,EAAUG,QAC1BC,EAAa1P,EAAMuP,QACzBG,EAAWT,GAAKjP,EAAMiP,GAAK,EAC3B,MAAMU,EAAsBD,EAAWD,QAEnCD,EAAcjc,OAAS,GACvBic,EAAcjc,SAAWoc,EAAepc,QACd,WAA1Bic,EAAc,GAAGhgB,MACS,YAA1BggB,EAAc,GAAGhgB,MACjBggB,EAAchR,IAAKrN,GAAcwO,EAAAzO,QAAUC,IAAO4N,KAAK,MACnD4Q,EAAenR,IAAKrN,GAAcwO,EAAAzO,QAAUC,IAAO4N,KAAK,IAE5DiB,EAAM4P,UAAU,IAAM,IAAIvC,EACtBmC,EACA,GACAA,EAAcjC,SAGlBiC,EAAcjc,OAAS,GACG,WAA1Bic,EAAc,GAAGhgB,MACS,YAA1BggB,EAAc,GAAGhgB,MAEjBwQ,EAAMoP,aAAa9a,KACf,IAAI8Z,EAAMQ,EAAeD,EAAca,EAAeG,SAI9D3P,EAAMoP,aAAa9a,KAAK,IAAI8Z,EAAMQ,EAAeD,QAlGvD,CACE,MAAMO,EAAYL,EAAQ1P,QAAQ4P,GAClC,GAAIG,GAAa,EAAG,CAChB,MAAMW,EAAqB7P,EAAMuP,QACjCM,EAAcZ,GAAKC,EACnB,MAAMY,EAAoBD,EAAcJ,QAMxC,GALAzP,EAAM4P,UAAUhB,EAActB,MAAQ,IAAID,EACtCyC,EACAlB,EAActB,KACduC,EAActC,SAGdqB,EAActB,QAAQT,GACO,IAA7BiD,EAAkBvc,QACY,WAA9Buc,EAAkB,GAAGtgB,MACrBsgB,EAAkB,GAAG3C,MAAMa,MAAO7c,GAA4B,gBAAdA,EAAK3B,MAErDsgB,EAAkB,GAAG3C,MAAMY,QAAS5c,IAChC,MAAM4e,EAAgBlD,EAAuB+B,EAActB,MAC3DtN,EAAMgQ,SAAS7e,EAAK2O,UAAUtQ,KAAOugB,EAAa9Q,MAAM,KAAK,GAEzD9N,EAAK8e,iBACJjQ,EAAMgQ,SAAS7e,EAAK2O,UAAUoQ,QAAQhI,SAAS/W,EAAK8e,iBAErDjQ,EAAMgQ,SAAS7e,EAAK2O,UAAUoQ,QAAQ5b,KAAKnD,EAAK8e,yBAGjDjQ,EAAM4P,UAAUhB,EAActB,WAClC,GACHsB,EAActB,QAAQT,GAC+B,IAArD7M,EAAM4P,UAAUhB,EAActB,MAAMH,MAAM5Z,QACY,WAAtDyM,EAAM4P,UAAUhB,EAActB,MAAMH,MAAM,GAAG3d,MACiB,IAA9DwQ,EAAM4P,UAAUhB,EAActB,MAAMH,MAAM,GAAGA,MAAM5Z,QACY,UAA/DyM,EAAM4P,UAAUhB,EAActB,MAAMH,MAAM,GAAGA,MAAM,GAAG3d,MACtDyB,EAAUG,WACN4O,EAAM4P,UAAUhB,EAActB,MAAMH,MAAM,GAAGA,MAAM,GAAGrN,UAG1D,GAEQE,EAAM4P,UAAUhB,EAActB,MAAMH,MAAM,GAAGA,MAAM,GAAGrN,YACtDE,EAAMmQ,UAQP,CACH,MAAMJ,EAAgBlD,EAAuB+B,EAActB,MAC3DtN,EAAMmQ,UACFnQ,EAAM4P,UAAUhB,EAActB,MAAMH,MAAM,GAAGA,MAAM,GAAGrN,UACxDqO,MAAQ4B,EAAa9Q,MAAM,KAAK,UAC3Be,EAAM4P,UAAUhB,EAActB,UAXvC,CACE,MAAMyC,EAAgBlD,EAAuB+B,EAActB,MAC3DtN,EAAMmQ,UACFnQ,EAAM4P,UAAUhB,EAActB,MAAMH,MAAM,GAAGA,MAAM,GAAGrN,UACtD,IAAIoO,EAAS6B,EAAa9Q,MAAM,KAAK,GAAI,WACtCe,EAAM4P,UAAUhB,EAActB,aA/DjDtN,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAI8Z,EAAMQ,EAAeD,SANrD3O,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAI8Z,EAAMQ,EAAeD,qFCnN5ClgB,EAAA2hB,sBAAwB,EAACC,EAAsBC,EAAc,KACtE,IAAIC,EAAmB,GAiCvB,OAhCAF,EAAgBtC,QAASyC,IACrB,GAAyB,UAArBA,EAAYhhB,MAAoBghB,EAAY9B,MAAO,CACnD,MAAMd,EAAY4C,EAAYnf,WACxBof,EAAoBD,EAAY9B,MAAMgC,OAAQzhB,GAAWA,EAAE0hB,WAAa,GAC9E,GAAiC,IAA7BF,EAAkBld,QAA8C,UAA9Bkd,EAAkB,GAAGjhB,KAAkB,CACzE+gB,GAAoB,IAAIK,OAAON,GAAe,KAAO1C,EAAY,OACjE2C,GAAoB9hB,EAAA2hB,sBAAsBI,EAAY/B,KAAM6B,EAAc,GAC1EC,GAAoB,IAAIK,OAAON,GAAe,UAC9C,MAAMO,EAAepiB,EAAA2hB,sBAAsBI,EAAY9B,MAAO4B,GAC1DO,EAAavd,OAAOwd,WAAW,MAC/BP,GAAoBM,EAAavd,OAAS,MAE1Cid,GACI,MACAM,EACK5R,MAAM,MACNyR,OAAOxhB,GAAKA,GACZsP,IAAItP,GAAK,IAAI0hB,OAAO,GAAK1hB,GACzB6P,KAAK,MACdwR,GAAoB,KAAO,IAAIK,OAAON,GAAe,YAGzDC,GAAoB,IAAIK,OAAON,GAAe,KAAO1C,EAAY,OACjE2C,GAAoB9hB,EAAA2hB,sBAAsBI,EAAY/B,KAAM6B,EAAc,GAC1EC,GAAoB,IAAIK,OAAON,GAAe,aAC9CC,GAAoB9hB,EAAA2hB,sBAAsBI,EAAY9B,MAAO4B,EAAc,GAC3EC,GAAoB,IAAIK,OAAON,GAAe,WAGlDC,GAAoB,IAAIK,OAAON,GAAeE,EAAYnf,WAAa,OAGxEkf,IAGX9hB,EAAAyC,QAAezC,EAAA2hB,qGCrCf,MAAAW,EAAAhiB,EAAA,IACAiiB,EAAAjiB,EAAA,IACAkiB,EAAAliB,EAAA,GACAmiB,EAAAniB,EAAA,GACAoiB,EAAApiB,EAAA,IAQcN,EAAA2iB,YARPD,EAAAjgB,QACP,MAAAmgB,EAAAtiB,EAAA,IAOSN,EAAA6iB,IAPFD,EAAAngB,QAEMzC,EAAAmhB,UAAiBmB,EACjBtiB,EAAA8iB,OAAcP,EACdviB,EAAAoe,eAAsBoE,EACtBxiB,EAAA+iB,YAAmBN,o4urHCVhC,MAAAjgB,EAAAlC,EAAA,GACA8d,EAAA9d,EAAA,GAEM0iB,EAAc,CAAC9O,EAAWD,IACf,WAATA,EACO,IAAM9B,EAAOU,KAAKqB,EAAM,OAAOtR,SAAS,QAAU,IACzC,YAATqR,EACA,KAAOC,EAAK+O,UAAU,IACb,YAAThP,GAA+B,UAATA,EACtBzR,EAAU0R,EAAM,IAAItR,WACX,SAATqR,IACEzR,EAAU0R,EAAM,IAAIpJ,UAAUlI,WAEhCsR,EAIflU,EAAAyC,QAAA,MAUI2O,YAAY8R,GACJA,IACI,cAAeA,IACf9e,KAAK+e,UAAYD,EAAkBC,WAEnC,gBAAiBD,IACjB9e,KAAKgf,YAAcF,EAAkBE,aAErC,SAAUF,IACV9e,KAAKyO,KAAOqQ,EAAkBrQ,MAE9B,QAASqQ,IACT9e,KAAKif,IAAMH,EAAkBG,KAE7B,aAAcH,IACd9e,KAAKkf,SAAWJ,EAAkBI,UAElC,UAAWJ,IACX9e,KAAKmf,MAAQL,EAAkBK,MAAMhG,QAAQ,KAAM,KAEnD,OAAQ2F,IACR9e,KAAKof,GAAKN,EAAkBM,IAE5B,UAAWN,IACX9e,KAAK3C,MAAQyhB,EAAkBzhB,QAK3C2P,SAASmS,GACLnf,KAAKmf,MAAQA,EAAMhG,QAAQ,KAAM,IAGrCnM,kBACI,SAAIhN,KAAKmf,OAASnf,KAAKmf,MAAMze,QAAU,IAC5BV,KAAKmf,MAAM1N,OAAO,EAAG,GAMpCzE,cACI,MAAMqS,EAAerf,KAAKsf,kBAC1B,SAAID,GAAgBA,KAAgBrF,IACxBA,EAAuBqF,GAMvCrS,kBACI,MAAMuS,EAAcvf,KAAKwf,cACzB,QAAID,GACOA,EAAYnT,MAAM,KAAK,GAMtCY,kBACI,OAAIhN,KAAKmf,OAASnf,KAAKmf,MAAMze,QAAU,GAC5BV,KAAKmf,MAAM1N,OAAO,GAAGsD,MAAM,YAE3B,GAIf/H,aAAayS,GAAuB,GAChC,MAAMzE,EAAehb,KAAKwf,cACpBE,EAAoB1f,KAAK2f,kBAC/B,GAAI3E,GAAgBhb,KAAKmf,MAAO,CAC5B,MAAMS,EAAuB5E,EACxB5O,MAAM,KAAK,GACXvJ,MAAM,GAAI,GACVuJ,MAAM,KACX,GACoC,IAAhCwT,EAAqBlf,QACO,KAA5Bkf,EAAqB,IACQ,IAA7BF,EAAkBhf,OAElB,MAAO,GACJ,CACH,MAAMgD,EAAmB,GACzB,IAAK,IAAItH,EAAI,EAAGA,EAAIwjB,EAAqBlf,OAAQtE,IAAK,CAClD,MAAMyjB,EAAuBD,EAAqBxjB,IAAM,UAClD0jB,EAAmBJ,EAAkBtjB,GAC3C,GAA6B,WAAzByjB,EAAmC,CACnC,MAAM5S,EAAW7O,EAAU0hB,EAAkB,IACxCla,OAAO,IACPoC,aACCtH,EAAStC,EAAUshB,EAAkBzS,GAAW,IACjD/G,SAAS,GACT8B,aACC8H,EAAO9P,KAAKmf,MAAMN,UAAU,GAAGpN,OAAwB,IAAhBxE,EAAW,GAASvM,GACjEgD,EAAOjC,KAAKmd,EAAY9O,EAAM+P,SAE9Bnc,EAAOjC,KAAKmd,EAAYkB,EAAkBD,IAGlD,OAAOnc,GAGX,OAAOgc,EAIf1S,qBACI,OAAmB,OAAZhN,KAAKof,6CCtIpB,IAAAW,EAGAA,EAAA,WACA,OAAA/f,KADA,GAIA,IAEA+f,KAAA,IAAAC,SAAA,iBACC,MAAA3V,GAED,iBAAArO,SAAA+jB,EAAA/jB,QAOAH,EAAAD,QAAAmkB,gCCjBAnkB,EAAAkT,WAuCA,SAAAmR,GACA,IAAAC,EAAAC,EAAAF,GACAG,EAAAF,EAAA,GACAG,EAAAH,EAAA,GACA,UAAAE,EAAAC,GAAA,EAAAA,GA1CAzkB,EAAAsd,YAiDA,SAAA+G,GAeA,IAdA,IAAA7V,EACA8V,EAAAC,EAAAF,GACAG,EAAAF,EAAA,GACAG,EAAAH,EAAA,GAEA1f,EAAA,IAAA8f,EAVA,SAAAL,EAAAG,EAAAC,GACA,UAAAD,EAAAC,GAAA,EAAAA,EASAE,CAAAN,EAAAG,EAAAC,IAEAG,EAAA,EAGA/Q,EAAA4Q,EAAA,EACAD,EAAA,EACAA,EAEAhkB,EAAA,EAAiBA,EAAAqT,EAASrT,GAAA,EAC1BgO,EACAqW,EAAAR,EAAAnO,WAAA1V,KAAA,GACAqkB,EAAAR,EAAAnO,WAAA1V,EAAA,QACAqkB,EAAAR,EAAAnO,WAAA1V,EAAA,OACAqkB,EAAAR,EAAAnO,WAAA1V,EAAA,IACAoE,EAAAggB,KAAApW,GAAA,OACA5J,EAAAggB,KAAApW,GAAA,MACA5J,EAAAggB,KAAA,IAAApW,EAGA,IAAAiW,IACAjW,EACAqW,EAAAR,EAAAnO,WAAA1V,KAAA,EACAqkB,EAAAR,EAAAnO,WAAA1V,EAAA,OACAoE,EAAAggB,KAAA,IAAApW,GAGA,IAAAiW,IACAjW,EACAqW,EAAAR,EAAAnO,WAAA1V,KAAA,GACAqkB,EAAAR,EAAAnO,WAAA1V,EAAA,OACAqkB,EAAAR,EAAAnO,WAAA1V,EAAA,OACAoE,EAAAggB,KAAApW,GAAA,MACA5J,EAAAggB,KAAA,IAAApW,GAGA,OAAA5J,GA1FA5E,EAAA6W,cAiHA,SAAAiO,GAQA,IAPA,IAAAtW,EACAqF,EAAAiR,EAAAhgB,OACAigB,EAAAlR,EAAA,EACAmR,EAAA,GAIAxkB,EAAA,EAAAykB,EAAApR,EAAAkR,EAA0CvkB,EAAAykB,EAAUzkB,GAHpD,MAIAwkB,EAAAnf,KAAAqf,EACAJ,EAAAtkB,IALA,MAKAykB,IAAAzkB,EALA,QAUA,IAAAukB,GACAvW,EAAAsW,EAAAjR,EAAA,GACAmR,EAAAnf,KACAsf,EAAA3W,GAAA,GACA2W,EAAA3W,GAAA,MACA,OAEG,IAAAuW,IACHvW,GAAAsW,EAAAjR,EAAA,OAAAiR,EAAAjR,EAAA,GACAmR,EAAAnf,KACAsf,EAAA3W,GAAA,IACA2W,EAAA3W,GAAA,MACA2W,EAAA3W,GAAA,MACA,MAIA,OAAAwW,EAAA1U,KAAA,KA1IA,IALA,IAAA6U,EAAA,GACAN,EAAA,GACAH,EAAA,oBAAAlS,sBAAAtN,MAEAiY,EAAA,mEACA3c,EAAA,EAAAqT,EAAAsJ,EAAArY,OAAkCtE,EAAAqT,IAASrT,EAC3C2kB,EAAA3kB,GAAA2c,EAAA3c,GACAqkB,EAAA1H,EAAAjH,WAAA1V,MAQA,SAAA+jB,EAAAF,GACA,IAAAxQ,EAAAwQ,EAAAvf,OAEA,GAAA+O,EAAA,IACA,UAAA7K,MAAA,kDAKA,IAAAwb,EAAAH,EAAA3T,QAAA,KAOA,OANA,IAAA8T,MAAA3Q,GAMA,CAAA2Q,EAJAA,IAAA3Q,EACA,EACA,EAAA2Q,EAAA,GAqEA,SAAAU,EAAAJ,EAAApV,EAAAkH,GAGA,IAFA,IAAApI,EARA4W,EASAC,EAAA,GACA7kB,EAAAkP,EAAqBlP,EAAAoW,EAASpW,GAAA,EAC9BgO,GACAsW,EAAAtkB,IAAA,cACAskB,EAAAtkB,EAAA,cACA,IAAAskB,EAAAtkB,EAAA,IACA6kB,EAAAxf,KAdAsf,GADAC,EAeA5W,IAdA,OACA2W,EAAAC,GAAA,OACAD,EAAAC,GAAA,MACAD,EAAA,GAAAC,IAaA,OAAAC,EAAA/U,KAAA,IAhGAuU,EAAA,IAAA3O,WAAA,OACA2O,EAAA,IAAA3O,WAAA,sBCnBAlW,EAAAmV,KAAA,SAAAnB,EAAAyB,EAAA6P,EAAAC,EAAAC,GACA,IAAA/W,EAAA7N,EACA6kB,EAAA,EAAAD,EAAAD,EAAA,EACAG,GAAA,GAAAD,GAAA,EACAE,EAAAD,GAAA,EACAE,GAAA,EACAplB,EAAA8kB,EAAAE,EAAA,IACA1kB,EAAAwkB,GAAA,IACA/iB,EAAAyR,EAAAyB,EAAAjV,GAOA,IALAA,GAAAM,EAEA2N,EAAAlM,GAAA,IAAAqjB,GAAA,EACArjB,KAAAqjB,EACAA,GAAAH,EACQG,EAAA,EAAWnX,EAAA,IAAAA,EAAAuF,EAAAyB,EAAAjV,MAAAM,EAAA8kB,GAAA,GAKnB,IAHAhlB,EAAA6N,GAAA,IAAAmX,GAAA,EACAnX,KAAAmX,EACAA,GAAAL,EACQK,EAAA,EAAWhlB,EAAA,IAAAA,EAAAoT,EAAAyB,EAAAjV,MAAAM,EAAA8kB,GAAA,GAEnB,OAAAnX,EACAA,EAAA,EAAAkX,MACG,IAAAlX,IAAAiX,EACH,OAAA9kB,EAAAilB,IAAA3a,KAAA3I,GAAA,KAEA3B,GAAA6D,KAAAf,IAAA,EAAA6hB,GACA9W,GAAAkX,EAEA,OAAApjB,GAAA,KAAA3B,EAAA6D,KAAAf,IAAA,EAAA+K,EAAA8W,IAGAvlB,EAAAyT,MAAA,SAAAO,EAAAvS,EAAAgU,EAAA6P,EAAAC,EAAAC,GACA,IAAA/W,EAAA7N,EAAAC,EACA4kB,EAAA,EAAAD,EAAAD,EAAA,EACAG,GAAA,GAAAD,GAAA,EACAE,EAAAD,GAAA,EACAI,EAAA,KAAAP,EAAA9gB,KAAAf,IAAA,OAAAe,KAAAf,IAAA,SACAlD,EAAA8kB,EAAA,EAAAE,EAAA,EACA1kB,EAAAwkB,EAAA,KACA/iB,EAAAd,EAAA,OAAAA,GAAA,EAAAA,EAAA,MAmCA,IAjCAA,EAAAgD,KAAAyE,IAAAzH,GAEAoT,MAAApT,QAAAyJ,KACAtK,EAAAiU,MAAApT,GAAA,IACAgN,EAAAiX,IAEAjX,EAAAhK,KAAAC,MAAAD,KAAA0H,IAAA1K,GAAAgD,KAAAshB,KACAtkB,GAAAZ,EAAA4D,KAAAf,IAAA,GAAA+K,IAAA,IACAA,IACA5N,GAAA,IAGAY,GADAgN,EAAAkX,GAAA,EACAG,EAAAjlB,EAEAilB,EAAArhB,KAAAf,IAAA,IAAAiiB,IAEA9kB,GAAA,IACA4N,IACA5N,GAAA,GAGA4N,EAAAkX,GAAAD,GACA9kB,EAAA,EACA6N,EAAAiX,GACKjX,EAAAkX,GAAA,GACL/kB,GAAAa,EAAAZ,EAAA,GAAA4D,KAAAf,IAAA,EAAA6hB,GACA9W,GAAAkX,IAEA/kB,EAAAa,EAAAgD,KAAAf,IAAA,EAAAiiB,EAAA,GAAAlhB,KAAAf,IAAA,EAAA6hB,GACA9W,EAAA,IAIQ8W,GAAA,EAAWvR,EAAAyB,EAAAjV,GAAA,IAAAI,EAAAJ,GAAAM,EAAAF,GAAA,IAAA2kB,GAAA,GAInB,IAFA9W,KAAA8W,EAAA3kB,EACA6kB,GAAAF,EACQE,EAAA,EAAUzR,EAAAyB,EAAAjV,GAAA,IAAAiO,EAAAjO,GAAAM,EAAA2N,GAAA,IAAAgX,GAAA,GAElBzR,EAAAyB,EAAAjV,EAAAM,IAAA,IAAAyB,kBClFA,IAAAK,EAAA,GAAiBA,SAEjB3C,EAAAD,QAAAkF,MAAA+M,SAAA,SAAArN,GACA,wBAAAhC,EAAAjC,KAAAiE,mBCHA3E,EAAAD,QAAA,SAAAC,GAoBA,OAnBAA,EAAA+lB,kBACA/lB,EAAAgmB,UAAA,aACAhmB,EAAAimB,MAAA,GAEAjmB,EAAAkmB,WAAAlmB,EAAAkmB,SAAA,IACAjlB,OAAAC,eAAAlB,EAAA,UACAmB,YAAA,EACAC,IAAA,WACA,OAAApB,EAAAQ,KAGAS,OAAAC,eAAAlB,EAAA,MACAmB,YAAA,EACAC,IAAA,WACA,OAAApB,EAAAO,KAGAP,EAAA+lB,gBAAA,GAEA/lB,+FCpBA,MAAMmmB,EAAa9lB,EAAQ,IAC3B8d,EAAA9d,EAAA,GACAyiB,EAAAziB,EAAA,GACA+lB,EAAA/lB,EAAA,IACAgmB,EAAAhmB,EAAA,IACAimB,EAAAjmB,EAAA,IACAkmB,EAAAlmB,EAAA,IACAmmB,EAAAnmB,EAAA,IACAomB,EAAApmB,EAAA,IACAqmB,EAAArmB,EAAA,IAEAsmB,EAAAtmB,EAAA,IAKA,MAAMuiB,EAiBFzR,YAAY+L,GACR/Y,KAAKoc,GAAK,EACVpc,KAAKgc,QAAU,GACfhc,KAAKuc,aAAe,GACpBvc,KAAKqN,MAAQ,IAAImV,EAAAnkB,QACjB2B,KAAKuN,OAAS,GACdvN,KAAKyiB,QAAU,GACfziB,KAAKsc,MAAQ,GACbtc,KAAKmd,SAAW,GAChBnd,KAAK0iB,MAAQ,EACb1iB,KAAKwc,QAAS,EACdxc,KAAK+c,UAAY,GACjB/c,KAAKsd,UAAY,GACjBtd,KAAK0e,OAAS,GACd1e,KAAK0a,QAAU,EAEX1a,KAAK+Y,KADLA,aAAgBhL,EACJgL,EAEAhL,EAAOU,KAAKsK,EAAKI,QAAQ,KAAM,IAAK,OAIxDnM,QACI,MAAM0P,EAAQ,IAAI+B,EAAIze,KAAK+Y,MAa3B,OAZA2D,EAAMN,GAAKpc,KAAKoc,GAChBM,EAAMV,QAAUhc,KAAKgc,QACrBU,EAAMrP,MAAQrN,KAAKqN,MAAMqP,QACzBA,EAAMnP,OAAMzQ,OAAA6lB,OAAA,GAAQ3iB,KAAKuN,QACzBmP,EAAM+F,QAAUziB,KAAKyiB,QACrB/F,EAAMJ,MAAKxf,OAAA6lB,OAAA,GAAQ3iB,KAAKsc,OACxBI,EAAMS,SAAWnd,KAAKmd,SACtBT,EAAMgG,MAAQ1iB,KAAK0iB,MAAQ,EAC3BhG,EAAMK,UAAY/c,KAAK+c,UACvBL,EAAMY,UAAYtd,KAAKsd,UACvBZ,EAAMgC,OAAS1e,KAAK0e,OACpBhC,EAAMhC,QAAU1a,KAAK0a,QACdgC,EAGX1P,cACI,MAAO,KAAOhN,KAAK+Y,KAAKva,SAAS,OAGrCwO,aACI,GAA4B,IAAxBhN,KAAKgc,QAAQtb,OACb,IAAK,IAAIkiB,EAAQ,EAAGA,EAAQ5iB,KAAK+Y,KAAKrY,OAAQkiB,IAAS,CACnD,MAAMC,EAAYb,EAAWhiB,KAAK+Y,KAAK6J,IAAQ,GAG/C,GAFAC,EAAUzG,GAAKwG,EACf5iB,KAAKgc,QAAQva,KAAKohB,GACdA,EAAUlmB,KAAKshB,WAAW,QAAS,CACnC,MAAM6E,EAAiB9iB,KAAK+Y,KAAK6J,GAAS,GACpCG,EAAW/iB,KAAK+Y,KAAKlW,MAAM+f,EAAQ,EAAGA,EAAQE,EAAiB,GACrED,EAAUE,SAAWA,EACrBH,GAASE,GAIrB,OAAO9iB,KAAKgc,QAGhBhP,eACI,MAAO,IACA,IAAIgW,IACHhjB,KAAKic,aACA4B,OAAO3Q,GAA0B,UAAhBA,EAAOvQ,MACxBgP,IAAIuB,GAAWA,EAAO6V,SAAW7V,EAAO6V,SAASvkB,SAAS,OAAS,IACnEqf,OAAOpD,GAAQA,KAAQT,GACvBrO,IAAI8O,GAAST,EAAuBS,MAKrDzN,YACI,MAAO,IACA,IAAIgW,IACHhjB,KAAKic,aACA4B,OAAO3Q,GAA0B,WAAhBA,EAAOvQ,MACxBgP,IAAIuB,GAAWA,EAAO6V,SAAW7V,EAAO6V,SAASvkB,SAAS,OAAS,IACnEqf,OAAOpD,GAAQA,KAAQkE,GACvBhT,IAAI8O,GAASkE,EAAoBlE,MAKlDzN,sBACI,OAAOhN,KAAKic,aACP4B,OAAO3Q,GAA0B,aAAhBA,EAAOvQ,MACxBgP,IAAIuB,GAAUA,EAAOkP,IAG9BpP,cACI,OAAOhN,KAAKic,aACPtQ,IAAIuB,GAAUA,EAAO+V,KACrBC,OAAO,CAAChiB,EAAWC,IAAcD,EAAIC,GAG9C6L,eACI,MAEM+H,EADW/U,KAAKmjB,cACCpO,MAFT,yCAGd,SAAIA,IAASA,EAAM,KACR,UAAYA,EAAM,GAMjC/H,QACIhN,KAAKoc,GAAK,EACVpc,KAAKuc,aAAe,GACpBvc,KAAKqN,MAAM+V,QACXpjB,KAAKuN,OAAS,GACdvN,KAAKyiB,QAAU,GACfziB,KAAKsc,MAAQ,GACbtc,KAAKmd,SAAW,GAChBnd,KAAK+c,UAAY,GACjB/c,KAAKsd,UAAY,GACjBtd,KAAK0e,OAAS,GACd1e,KAAK0a,QAAU,EAGnB1N,QACI,GAAiC,IAA7BhN,KAAKuc,aAAa7b,OAAc,CAChC,MAAMsb,EAAUhc,KAAKic,aACrB,IAAKjc,KAAKoc,GAAIpc,KAAKoc,GAAKJ,EAAQtb,SAAWV,KAAKwc,OAAQxc,KAAKoc,KAAM,CAC/D,MAAMlP,EAAS8O,EAAQhc,KAAKoc,IAE5B,GADApc,KAAK0a,SAAWxN,EAAO+V,MACjB/V,EAAOvQ,QAAQslB,EAAA5jB,SACjB,MAAM,IAAIuG,MAAM,mBAAqBsI,EAAOvQ,MAE3CslB,EAAA5jB,QAAwB6O,EAAOvQ,MAAMuQ,EAAQlN,OAI1D,OAAOA,KAAKuc,aAGhBvP,YACI,MAAMwQ,EAAkBxd,KAAK4c,QAW7B,OAVesF,EAAA7jB,QAAgB2B,KAAK0e,OAAQ1e,KAAKqjB,aACjClB,EAAA9jB,QAAiB2B,KAAKmd,UACrBiF,EAAA/jB,QAAkB2B,KAAKmd,UACtBkF,EAAAhkB,QAAmB2B,KAAKsd,WACxBxgB,OAAOwmB,KAAKtjB,KAAK+c,WAC9BpR,IAAKqP,GACFsH,EAAAjkB,QAAmB2c,EAAchb,KAAK+c,UAAU/B,KAEnD9O,KAAK,IACGqW,EAAAlkB,QAAsBmf,IAK3C5hB,EAAAyC,QAAeogB,yDCxLf,IAAA8E,EAAA,CAGAC,EAAA,kBACAC,EAAA,iBACAC,EAAA,iBACAC,EAAA,iBACAC,EAAA,iBACAC,EAAA,kBACAC,EAAA,iBACAC,EAAA,kBACAC,EAAA,oBACAC,EAAA,oBACAC,GAAA,kBACAC,GAAA,wBAGAC,GAAA,gBACAC,GAAA,gBACAC,GAAA,iBACAC,GAAA,iBACAC,GAAA,gBACAC,GAAA,oBACAC,GAAA,iBACAC,GAAA,gBACAC,GAAA,iBACAC,GAAA,iBACAC,GAAA,kBACAC,GAAA,iBACAC,GAAA,iBACAC,GAAA,iBAGAC,GAAA,mBAGAC,GAAA,qBACAC,GAAA,0BACAC,GAAA,oBACAC,GAAA,oBACAC,GAAA,uBACAC,GAAA,0BACAC,GAAA,0BACAC,GAAA,0BACAC,GAAA,sBACAC,GAAA,sBACAC,GAAA,sBACAC,GAAA,8BACAC,GAAA,8BACAC,GAAA,4BACAC,GAAA,4BACAC,GAAA,8BAGAC,GAAA,2BACAC,GAAA,sBACAC,GAAA,uBACAC,GAAA,oBACAC,GAAA,wBACAC,GAAA,sBAGAC,GAAA,iBACAC,GAAA,mBACAC,GAAA,oBACAC,GAAA,qBACAC,GAAA,wBACAC,GAAA,uBACAC,GAAA,kBACAC,GAAA,oBACAC,GAAA,gBACAC,GAAA,mBACAC,GAAA,iBACAC,GAAA,sBAGAC,GAAA,kBACAC,GAAA,kBACAC,GAAA,kBACAC,GAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBAEAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBACAC,IAAA,iBAEAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBACAC,IAAA,kBAEAC,IAAA,mBACAC,IAAA,mBACAC,IAAA,mBACAC,IAAA,mBACAC,IAAA,mBAGAC,IAAA,0BACAC,IAAA,uBACAC,IAAA,2BACAC,IAAA,oBACAC,IAAA,+BACAC,IAAA,2BACAC,IAAA,6BACAC,IAAA,oBAGAC,IAAA,qBACAC,IAAA,gCAGAtwB,EAAAD,QAAA,SAAAwwB,EAAAC,EAAAC,GACA,IAAAvT,EAAAwK,EAAA6I,GAAA7I,EAAA6I,GAAA,wBACAlf,EAAA6L,EAAA,GAEAsT,IACA,QAAAnf,IACAA,GAAAkf,EAAA,KAGA,SAAAlf,IACAA,GAAAkf,EAAA,IAGA,QAAAlf,IACAA,GAAAkf,EAAA,KAGA,SAAAlf,IACAA,GAAAkf,EAAA,MAIA,IAAAnJ,EAAAlK,EAAA,GAQA,OANAuT,GACA,QAAApf,IACA+V,EAAA,GAIA,CAAUtmB,KAAAuQ,SAAAkf,EAAAnJ,MAAAsJ,GAAAxT,EAAA,GAAAhN,IAAAgN,EAAA,GAAAyT,QAAAzT,EAAA,GAAA0T,MAAA1T,EAAA,oFCpMV,MAAA2T,EAAAxwB,EAAA,IACAywB,EAAAzwB,EAAA,GACA0wB,EAAA1wB,EAAA,GACA2wB,EAAA3wB,EAAA,GACA4wB,EAAA5wB,EAAA,IACA6wB,EAAA7wB,EAAA,GACA8wB,EAAA9wB,EAAA,IACA+wB,EAAA/wB,EAAA,IACAgxB,EAAAhxB,EAAA,IACAixB,EAAAjxB,EAAA,IACAkxB,EAAAlxB,EAAA,IACAmxB,EAAAnxB,EAAA,IACAoxB,EAAApxB,EAAA,IACAqxB,EAAArxB,EAAA,IACAsxB,EAAAtxB,EAAA,IACAuxB,EAAAvxB,EAAA,IACAwxB,EAAAxxB,EAAA,IACAyxB,EAAAzxB,EAAA,IACA0xB,EAAA1xB,EAAA,IACA2xB,EAAA3xB,EAAA,IACA4xB,EAAA5xB,EAAA,IACA6xB,EAAA7xB,EAAA,IACA8xB,EAAA9xB,EAAA,IACA+xB,EAAA/xB,EAAA,IACAgyB,EAAAhyB,EAAA,IACAiyB,EAAAjyB,EAAA,IACAkyB,EAAAlyB,EAAA,IACAmyB,EAAAnyB,EAAA,IACAoyB,EAAApyB,EAAA,IACAqyB,EAAAryB,EAAA,IACAsyB,EAAAtyB,EAAA,IACAuyB,EAAAvyB,EAAA,IACAwyB,EAAAxyB,EAAA,IACAyyB,EAAAzyB,EAAA,IACA0yB,EAAA1yB,EAAA,IACA2yB,EAAA3yB,EAAA,IACA4yB,EAAA5yB,EAAA,IACA6yB,EAAA7yB,EAAA,IACA8yB,EAAA9yB,EAAA,IACA+yB,EAAA/yB,EAAA,IACAgzB,EAAAhzB,EAAA,IACAizB,EAAAjzB,EAAA,IACAkzB,EAAAlzB,EAAA,IACAmzB,EAAAnzB,EAAA,IACAozB,EAAApzB,EAAA,IACAqzB,EAAArzB,EAAA,IACAszB,EAAAtzB,EAAA,GACAuzB,EAAAvzB,EAAA,IACAwzB,EAAAxzB,EAAA,IACAyzB,EAAAzzB,EAAA,IACA0zB,EAAA1zB,EAAA,IACA2zB,GAAA3zB,EAAA,IACA4zB,GAAA5zB,EAAA,IACA6zB,GAAA7zB,EAAA,IACA8zB,GAAA9zB,EAAA,IACA+zB,GAAA/zB,EAAA,IACAg0B,GAAAh0B,EAAA,IACAi0B,GAAAj0B,EAAA,IACAk0B,GAAAl0B,EAAA,IACAm0B,GAAAn0B,EAAA,IACAo0B,GAAAp0B,EAAA,IACAq0B,GAAAr0B,EAAA,IACAs0B,GAAAt0B,EAAA,IACAu0B,GAAAv0B,EAAA,IACAw0B,GAAAx0B,EAAA,IACAy0B,GAAAz0B,EAAA,IACA00B,GAAA10B,EAAA,IACA20B,GAAA30B,EAAA,IACA40B,GAAA50B,EAAA,IACA60B,GAAA70B,EAAA,IAEAN,EAAAyC,QAAe,CACX2yB,KAAAtE,EAAAruB,QACAmb,IAAAmT,EAAAtuB,QACAob,IAAAmT,EAAAvuB,QACAqb,IAAAmT,EAAAxuB,QACA4yB,IAAAnE,EAAAzuB,QACA6yB,KAAMpE,EAAAzuB,QACNmP,IAAAuf,EAAA1uB,QACA8yB,KAAMpE,EAAA1uB,QACN+yB,OAAApE,EAAA3uB,QACAgzB,OAAApE,EAAA5uB,QACAizB,IAAApE,EAAA7uB,QACAkzB,WAAApE,EAAA9uB,QACAwb,GAAAuT,EAAA/uB,QACA0b,GAAAsT,EAAAhvB,QACAmzB,IAAKpE,EAAA/uB,QACLozB,IAAKpE,EAAAhvB,QACLqzB,GAAApE,EAAAjvB,QACAszB,OAAApE,EAAAlvB,QACAuzB,IAAApE,EAAAnvB,QACAwzB,GAAApE,EAAApvB,QACAyzB,IAAApE,EAAArvB,QACA0zB,IAAApE,EAAAtvB,QACA2zB,KAAApE,EAAAvvB,QACAsb,IAAAkU,EAAAxvB,QACA4zB,IAAAnE,EAAAzvB,QACAub,IAAAmU,EAAA1vB,QACA6zB,KAAAlE,EAAA3vB,QACA8zB,QAAAlE,EAAA5vB,QACA+zB,QAAAlE,EAAA7vB,QACAg0B,OAAAlE,EAAA9vB,QACAi0B,OAAAlE,EAAA/vB,QACAk0B,UAAAlE,EAAAhwB,QACAm0B,aAAAlE,EAAAjwB,QACAo0B,aAAAlE,EAAAlwB,QACAq0B,aAAAlE,EAAAnwB,QACAs0B,SAAAlE,EAAApwB,QACAu0B,SAAAlE,EAAArwB,QACAw0B,SAAAlE,EAAAtwB,QACAy0B,YAAAlE,EAAAvwB,QACA00B,YAAAlE,EAAAxwB,QACA20B,eAAAlE,EAAAzwB,QACA40B,eAAAlE,EAAA1wB,QACA60B,YAAAlE,EAAA3wB,QACA80B,UAAAlE,EAAA5wB,QACA+0B,SAAAlE,EAAA7wB,QACAg1B,UAAAlE,EAAA9wB,QACAi1B,OAAAlE,EAAA/wB,QACAk1B,WAAAlE,EAAAhxB,QACAm1B,SAAAlE,EAAAjxB,QACAo1B,IAAAlE,EAAAlxB,QACA0O,MAAAyiB,EAAAnxB,QACAq1B,OAAAjE,EAAApxB,QACAs1B,QAASlE,EAAApxB,QACTu1B,MAAAlE,EAAArxB,QACAw1B,OAAAlE,EAAAtxB,QACAy1B,KAAAlE,EAAAvxB,QACAkd,MAAAsU,GAAAxxB,QACA01B,GAAAjE,GAAAzxB,QACA21B,MAAAjE,GAAA1xB,QACA41B,IAAAjE,GAAA3xB,QACA61B,SAAAjE,GAAA5xB,QACA81B,MAAOjE,GAAA7xB,QACP+1B,MAAOlE,GAAA7xB,QACPg2B,MAAOnE,GAAA7xB,QACPi2B,MAAOpE,GAAA7xB,QACPk2B,MAAOrE,GAAA7xB,QACPm2B,MAAOtE,GAAA7xB,QACPo2B,MAAOvE,GAAA7xB,QACPq2B,MAAOxE,GAAA7xB,QACPs2B,MAAOzE,GAAA7xB,QACPu2B,OAAQ1E,GAAA7xB,QACRw2B,OAAQ3E,GAAA7xB,QACRy2B,OAAQ5E,GAAA7xB,QACR02B,OAAQ7E,GAAA7xB,QACR22B,OAAQ9E,GAAA7xB,QACR42B,OAAQ/E,GAAA7xB,QACR62B,OAAQhF,GAAA7xB,QACR82B,OAAQjF,GAAA7xB,QACR+2B,OAAQlF,GAAA7xB,QACRg3B,OAAQnF,GAAA7xB,QACRi3B,OAAQpF,GAAA7xB,QACRk3B,OAAQrF,GAAA7xB,QACRm3B,OAAQtF,GAAA7xB,QACRo3B,OAAQvF,GAAA7xB,QACRq3B,OAAQxF,GAAA7xB,QACRs3B,OAAQzF,GAAA7xB,QACRu3B,OAAQ1F,GAAA7xB,QACRw3B,OAAQ3F,GAAA7xB,QACRy3B,OAAQ5F,GAAA7xB,QACR03B,OAAQ7F,GAAA7xB,QACR23B,OAAQ9F,GAAA7xB,QACR43B,OAAQ/F,GAAA7xB,QACR63B,OAAQhG,GAAA7xB,QACR83B,KAAMhG,GAAA9xB,QACN+3B,KAAMjG,GAAA9xB,QACNg4B,KAAMlG,GAAA9xB,QACNi4B,KAAMnG,GAAA9xB,QACNk4B,KAAMpG,GAAA9xB,QACNm4B,KAAMrG,GAAA9xB,QACNo4B,KAAMtG,GAAA9xB,QACNq4B,KAAMvG,GAAA9xB,QACNs4B,KAAMxG,GAAA9xB,QACNu4B,MAAOzG,GAAA9xB,QACPw4B,MAAO1G,GAAA9xB,QACPy4B,MAAO3G,GAAA9xB,QACP04B,MAAO5G,GAAA9xB,QACP24B,MAAO7G,GAAA9xB,QACP44B,MAAO9G,GAAA9xB,QACP64B,MAAO/G,GAAA9xB,QACP84B,MAAO/G,GAAA/xB,QACP+4B,MAAOhH,GAAA/xB,QACPg5B,MAAOjH,GAAA/xB,QACPi5B,MAAOlH,GAAA/xB,QACPk5B,MAAOnH,GAAA/xB,QACPm5B,MAAOpH,GAAA/xB,QACPo5B,MAAOrH,GAAA/xB,QACPq5B,MAAOtH,GAAA/xB,QACPs5B,MAAOvH,GAAA/xB,QACPu5B,OAAQxH,GAAA/xB,QACRw5B,OAAQzH,GAAA/xB,QACRy5B,OAAQ1H,GAAA/xB,QACR05B,OAAQ3H,GAAA/xB,QACR25B,OAAQ5H,GAAA/xB,QACR45B,OAAQ7H,GAAA/xB,QACR65B,OAAQ9H,GAAA/xB,QACR85B,KAAM9H,GAAAhyB,QACN+5B,KAAM/H,GAAAhyB,QACNg6B,KAAMhI,GAAAhyB,QACNi6B,KAAMjI,GAAAhyB,QACNk6B,KAAMlI,GAAAhyB,QACNm6B,OAAAlI,GAAAjyB,QACAo6B,KAAAlI,GAAAlyB,QACAq6B,SAAAlI,GAAAnyB,QACAs6B,OAAAlI,GAAApyB,QACAu6B,aAAAlI,GAAAryB,QACAw6B,QAAAlI,GAAAtyB,QACAy6B,WAAAlI,GAAAvyB,QACA06B,OAAAlI,GAAAxyB,QACA26B,QAAAlI,GAAAzyB,QACA46B,aAAAlI,GAAA1yB,wFChNJ,MAAa2yB,EAKThkB,cACIhN,KAAKrD,KAAO,OACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,WAXfpR,EAAAo1B,OAeAp1B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAIuvB,oFClBhC,MAAA5yB,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa+0B,EAOTjkB,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,MAAQc,EAAAzO,QAAU2B,KAAKyN,QAf7D7R,EAAAq1B,MAmBAr1B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAKpG,OAAO6H,IACtBrP,EAAUG,WAAWkP,IAAUA,EAAMpI,OAAO,GACnD8H,EAAME,MAAM5L,KAAKuK,GAEjBmB,EAAME,MAAM5L,KAAK,IAAIwvB,EAAIjlB,EAAMyB,qFC9BvC,MAAAkf,EAAAzwB,EAAA,GACA6wB,EAAA7wB,EAAA,GACAkC,EAAAlC,EAAA,GAEAN,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACpBrI,EAAMkI,EAAME,MAAMC,MACpBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,IAAUrP,EAAUG,WAAW0G,GAClFkI,EAAME,MAAM5L,KAAKuK,EAAK/K,IAAIwM,GAAOxI,IAAIA,IAC9B7G,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GAC1DN,EAAME,MAAM5L,KAAK,IAAIsrB,EAAAvf,IAAIxB,EAAK/K,IAAIwM,GAAQxI,IAE1CkI,EAAME,MAAM5L,KAAK,IAAIsrB,EAAAvf,IAAI,IAAImf,EAAAnT,IAAIxN,EAAMyB,GAAQxI,qFCbvD,MAAA2nB,EAAA1wB,EAAA,GACA6wB,EAAA7wB,EAAA,GACAkC,EAAAlC,EAAA,GAEAN,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACpBrI,EAAMkI,EAAME,MAAMC,MACpBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,IAAUrP,EAAUG,WAAW0G,GAClFkI,EAAME,MAAM5L,KAAKuK,EAAK9F,SAASuH,GAAOxI,IAAIA,IACnC7G,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GAC1DN,EAAME,MAAM5L,KAAK,IAAIsrB,EAAAvf,IAAIxB,EAAK9F,SAASuH,GAAQxI,IAE/CkI,EAAME,MAAM5L,KAAK,IAAIsrB,EAAAvf,IAAI,IAAIof,EAAAnT,IAAIzN,EAAMyB,GAAQxI,qFCbvD,MAAA7G,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAao1B,EAOTtkB,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,OAASc,EAAAzO,QAAU2B,KAAKyN,QAf9D7R,EAAA01B,MAmBA11B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAK1M,IAAImO,IAE1BN,EAAME,MAAM5L,KAAK,IAAI6vB,EAAItlB,EAAMyB,qFC5BvC,MAAAogB,EAAA3xB,EAAA,IACA6xB,EAAA7xB,EAAA,IACA2wB,EAAA3wB,EAAA,GACAkC,EAAAlC,EAAA,GAEAN,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KACRgM,EAAMjL,UAAUpE,EAAU,IAAIwD,SAASoK,IAAOrC,WAAWvL,EAAU,IAAIwD,SAASoK,KAE7E5N,EAAUG,WAAWyN,GAC5BmB,EAAME,MAAM5L,KACR,IAAIssB,EAAAnU,IAAI,IAAIiU,EAAAlU,IAAIlM,EAAOrP,EAAU,IAAIwD,SAASoK,IAAQ5N,EAAU,IAAIwD,SAASoK,KAGjFmB,EAAME,MAAM5L,KACR,IAAIssB,EAAAnU,IAAI,IAAIiU,EAAAlU,IAAIlM,EAAO,IAAIof,EAAAnT,IAAItb,EAAU,IAAK4N,IAAQ,IAAI6gB,EAAAnT,IAAItb,EAAU,IAAK4N,sFClBzF,MAAA5N,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAag9B,EAMTlsB,YAAYyN,GACRza,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKya,KAAOA,EAGhBzN,WACI,MAAO,cAAgBhN,KAAKya,MAbpC7e,EAAAs9B,MAiBA,MAAaxH,EAOT1kB,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,KACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,OAASc,EAAAzO,QAAU2B,KAAKyN,QAf9D7R,EAAA81B,KAmBA91B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,IAAInB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACpBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKrD,GAAiC,IAAvB4N,EAAK3G,OAAOoI,GAAkB,EAAI,KAGzDrP,EAAUG,WAAWyN,IACN,QAAfyB,EAAM9Q,MACNyB,EAAUG,WAAWkP,EAAMA,SAE3BzB,EAAOA,EAAK9F,SAASuH,EAAMA,OAC3BA,EAAQA,EAAMzB,MAGd5N,EAAUG,WAAWkP,IACP,QAAdzB,EAAKrP,MACLyB,EAAUG,WAAWyN,EAAKyB,SAE1BA,EAAQA,EAAMvH,SAAS8F,EAAKyB,OAC5BzB,EAAOA,EAAKA,MAGZ5N,EAAUG,WAAWyN,IACrB,SAASO,KAAKP,EAAKxN,SAAS,IAAIqgB,UAAU,KAC3B,iBAAfpR,EAAM9Q,MACN8Q,EAAMR,SAAS5H,OAAO,GAEtB8H,EAAME,MAAM5L,KACR,IAAIy3B,EACA,IAAInb,OAAO,GAAK/R,EAAKxN,SAAS,IAAIkC,QAC9BsL,EAAKxN,SAAS,IAAIqgB,UAAU,EAAG,GAAK,GAAK7S,EAAKxN,SAAS,IAAIkC,WAIvEtC,EAAUG,WAAWkP,IACrB,SAASlB,KAAKkB,EAAMjP,SAAS,IAAIqgB,UAAU,KAC7B,iBAAd7S,EAAKrP,MACLqP,EAAKiB,SAAS5H,OAAO,GAErB8H,EAAME,MAAM5L,KACR,IAAIy3B,EACA,IAAInb,OAAO,GAAKtQ,EAAMjP,SAAS,IAAIkC,QAC/B+M,EAAMjP,SAAS,IAAIqgB,UAAU,EAAG,GAAK,GAAKpR,EAAMjP,SAAS,IAAIkC,WAIzEyM,EAAME,MAAM5L,KAAK,IAAIiwB,EAAG1lB,EAAMyB,sFCtF1C,MAAArP,EAAAlC,EAAA,GACAkxB,EAAAlxB,EAAA,IACAmxB,EAAAnxB,EAAA,IACA4Q,EAAA5Q,EAAA,GAEA,MAAay1B,EAMT3kB,YAAY1O,GACR0B,KAAKrD,KAAO,SACZqD,KAAKvB,SAAU,EACfuB,KAAK1B,KAAOA,EAGhB0O,WACI,OAAOF,EAAAzO,QAAU2B,KAAK1B,MAAQ,SAbtC1C,EAAA+1B,SAiBA/1B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM7O,EAAO6O,EAAME,MAAMC,MACrBlP,EAAUG,WAAWD,GACrB6O,EAAME,MAAM5L,KAAKrD,GAA4B,IAAlBE,EAAKoI,SAAoB,EAAI,IACnC,OAAdpI,EAAK3B,KACR2B,EAAKwb,MACL3M,EAAME,MAAM5L,KAAK,IAAI4rB,EAAAtT,GAAGzb,EAAK0N,KAAM1N,EAAKmP,QAExCN,EAAME,MAAM5L,KAAK,IAAI4rB,EAAAtT,GAAGzb,EAAK0N,KAAM1N,EAAKmP,OAAO,IAE9B,OAAdnP,EAAK3B,KACR2B,EAAKwb,MACL3M,EAAME,MAAM5L,KAAK,IAAI2rB,EAAAvT,GAAGvb,EAAK0N,KAAM1N,EAAKmP,QAExCN,EAAME,MAAM5L,KAAK,IAAI2rB,EAAAvT,GAAGvb,EAAK0N,KAAM1N,EAAKmP,OAAO,IAE5CnP,aAAgBqzB,EACvBxkB,EAAME,MAAM5L,KAAKnD,EAAKA,MAEtB6O,EAAME,MAAM5L,KAAK,IAAIkwB,EAAOrzB,qFCzCpC,MAAAF,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa01B,EAOT5kB,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,OAASc,EAAAzO,QAAU2B,KAAKyN,QAf9D7R,EAAAg2B,MAmBAh2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAKnC,IAAI4D,IACnBrP,EAAUG,WAAWyN,IAAS,SAASO,KAAKP,EAAKxN,SAAS,MACjEiP,EAAMwC,KAAOjE,EAAKxN,SAAS,IAAIkC,OAC/ByM,EAAME,MAAM5L,KAAKgM,IACVrP,EAAUG,WAAWkP,IAAU,SAASlB,KAAKkB,EAAMjP,SAAS,MACnEwN,EAAKiE,KAAOxC,EAAMjP,SAAS,IAAIkC,OAC/ByM,EAAME,MAAM5L,KAAKuK,IAcjB5N,EAAUG,WAAWyN,IACrByB,aAAiBmkB,GACjBxzB,EAAUG,WAAWkP,EAAMzB,OAC3BA,EAAK3G,OAAOoI,EAAMzB,MAElBmB,EAAME,MAAM5L,KAAKgM,EAAMA,OAEvBN,EAAME,MAAM5L,KAAK,IAAImwB,EAAI5lB,EAAMyB,qFCrDvC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa21B,EAOT7kB,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,KACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,OAASc,EAAAzO,QAAU2B,KAAKyN,QAf9D7R,EAAAi2B,KAmBAj2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAKlC,GAAG2D,IAEzBN,EAAME,MAAM5L,KAAK,IAAIowB,EAAG7lB,EAAMyB,qFC5BtC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa41B,EAOT9kB,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,MAAQc,EAAAzO,QAAU2B,KAAKyN,QAf7D7R,EAAAk2B,MAmBAl2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAKjC,IAAI0D,IAE1BN,EAAME,MAAM5L,KAAK,IAAIqwB,EAAI9lB,EAAMyB,qFC5BvC,MAAArP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa61B,EAMT/kB,YAAY1O,GACR0B,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAK1B,KAAOA,EAGhB0O,WACI,MAAO,IAAMF,EAAAzO,QAAU2B,KAAK1B,OAbpC1C,EAAAm2B,MAiBAn2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM7O,EAAO6O,EAAME,MAAMC,MACrBlP,EAAUG,WAAWD,GACrB6O,EAAME,MAAM5L,KAAKnD,EAAK8K,OAEtB+D,EAAME,MAAM5L,KAAK,IAAIswB,EAAIzzB,qFCzBjC,MAAAF,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa81B,EAOThlB,YAAYmsB,EAAerpB,GACvB9P,KAAKrD,KAAO,OACZqD,KAAKvB,SAAU,EACfuB,KAAKm5B,SAAWA,EAChBn5B,KAAK8P,KAAOA,EAGhB9C,WACI,MAAO,IAAMF,EAAAzO,QAAU2B,KAAK8P,MAAQ,OAAShD,EAAAzO,QAAU2B,KAAKm5B,UAAY,SAfhFv9B,EAAAo2B,OAmBAp2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMgsB,EAAWhsB,EAAME,MAAMC,MACvBwC,EAAO3C,EAAME,MAAMC,MACrBlP,EAAUG,WAAWuR,IAAS1R,EAAUG,WAAW46B,GACnDhsB,EAAME,MAAM5L,KAAKqO,EAAKnG,WAAWwvB,GAAUtvB,IAAI,IAE/CsD,EAAME,MAAM5L,KAAK,IAAIuwB,EAAKmH,EAAUrpB,qFC5B5C,MAAA1R,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa+1B,EAOTjlB,YAAYhB,EAAWyB,GACnBzN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKgM,KAAOA,EACZhM,KAAKyN,MAAQA,EAGjBT,WACI,OAAOF,EAAAzO,QAAU2B,KAAKgM,MAAQ,QAAUc,EAAAzO,QAAU2B,KAAKyN,QAf/D7R,EAAAq2B,MAmBAr2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMnB,EAAOmB,EAAME,MAAMC,MACnBG,EAAQN,EAAME,MAAMC,MACtBlP,EAAUG,WAAWyN,IAAS5N,EAAUG,WAAWkP,GACnDN,EAAME,MAAM5L,KAAKuK,EAAKrC,WAAW8D,IAEjCN,EAAME,MAAM5L,KAAK,IAAIwwB,EAAIjmB,EAAMyB,qFC5BvC,MAAA+hB,EAAAtzB,EAAA,GACAkC,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAag2B,EAQTllB,YAAYsN,EAAY8e,EAAmBC,GACvCr5B,KAAKrD,KAAO,OACZqD,KAAKvB,SAAU,EACX26B,GAAeC,GACfr5B,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,GAEpBr5B,KAAKsa,MAAQA,EAIrBtN,WACI,OAAIhN,KAAKsa,MACE,aAAeta,KAAKsa,MAAM3O,IAAKrN,GAAcwO,EAAAzO,QAAUC,IAAO4N,KAAK,MAAQ,IAG9E,oBACAY,EAAAzO,QAAU2B,KAAKo5B,aACf,KACAtsB,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,OA9BhBz9B,EAAAs2B,OAoCAt2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMisB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MACjC,GAAIlP,EAAUG,WAAW66B,IAAgBh7B,EAAUG,WAAW86B,GAAe,CACzE,MAAM/e,EAAQ,GACd,IACI,IAAIle,EAAIg9B,EAAYpxB,aACpB5L,EAAIg9B,EAAYn4B,IAAIo4B,GAAcrxB,aAClC5L,GAAK,GAEDA,KAAK+Q,EAAMI,OACX+M,EAAM7Y,KAAK0L,EAAMI,OAAOnR,IAExBke,EAAM7Y,KAAK,IAAI+tB,EAAAziB,MAAM3Q,IAG7B+Q,EAAME,MAAM5L,KAAK,IAAIywB,EAAK5X,SAE1BnN,EAAME,MAAM5L,KAAK,IAAIywB,EAAK,GAAIkH,EAAaC,qFCzDnD,MAAalH,EAKTnlB,cACIhN,KAAKrD,KAAO,UACZqD,KAAK6P,KAAO,UACZ7P,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,QAZfpR,EAAAu2B,UAgBAv2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI0wB,oFClBzB,MAAArlB,EAAA5Q,EAAA,GAEA,MAAak2B,EAMTplB,YAAYssB,GACRt5B,KAAKrD,KAAO,UACZqD,KAAKvB,SAAU,EACfuB,KAAKs5B,QAAUA,EAGnBtsB,WACI,OAAOF,EAAAzO,QAAU2B,KAAKs5B,SAAW,YAbzC19B,EAAAw2B,UAiBAx2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMmsB,EAAUnsB,EAAME,MAAMC,MAC5BH,EAAME,MAAM5L,KAAK,IAAI2wB,EAAQkH,qFCpBjC,MAAajH,EAKTrlB,cACIhN,KAAKrD,KAAO,SACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,aAXfpR,EAAAy2B,SAeAz2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI4wB,oFChBzB,MAAaC,EAKTtlB,cACIhN,KAAKrD,KAAO,SACZqD,KAAKrD,KAAO,UACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,cAZfpR,EAAA02B,SAgBA12B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI6wB,oFCjBzB,MAAaC,EAKTvlB,cACIhN,KAAKrD,KAAO,YACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,aAXfpR,EAAA22B,YAeA32B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI8wB,oFCjBzB,MAAAn0B,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAas2B,EAOTxlB,YAAYC,GACRjN,KAAKrD,KAAO,eACZqD,KAAKvB,SAAU,EACfuB,KAAKiN,SAAWA,EAGpBD,WACI,OAAI5O,EAAUG,WAAWyB,KAAKiN,WAAajN,KAAKiN,SAASvG,SAC9C,WAEPtI,EAAUG,WAAWyB,KAAKiN,WAC1BjN,KAAKiN,SACArL,SAAS,GACTqD,IAAI,IACJyB,SAGD,OACA1G,KAAKiN,SACArL,SAAS,GACTgE,OAAO,IACPpH,WAGF,YAAcsO,EAAAzO,QAAU2B,KAAKiN,UAAY,KA/B5DrR,EAAA42B,eAoCA52B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMosB,EAAgBpsB,EAAME,MAAMC,MAClCH,EAAME,MAAM5L,KAAK,IAAI+wB,EAAa+G,qFCxCtC,MAAa9G,EAKTzlB,cACIhN,KAAKrD,KAAO,eACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,mBAXfpR,EAAA62B,eAeA72B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAIgxB,oFChBzB,MAAaC,EAOT1lB,YAAYusB,EAAoBC,GAC5Bx5B,KAAKrD,KAAO,eACZqD,KAAKvB,SAAU,EACfuB,KAAKu5B,cAAgBA,EACrBv5B,KAAKw5B,WAAaA,EAGtBxsB,WACI,MACI,YACAhN,KAAKu5B,cACL,KACAv5B,KAAKu5B,cACL,IACAv5B,KAAKw5B,WACL,OAtBZ59B,EAAA82B,eA2BA92B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMC,EAAiBD,EAAME,MAAMC,MAC7BisB,EAAgBpsB,EAAME,MAAMC,MAC5BksB,EAAarsB,EAAME,MAAMC,MAC/BH,EAAMI,OAAOH,GAAkB,IAAIslB,EAAa6G,EAAeC,oFC/BnE,MAAa7G,EAKT3lB,cACIhN,KAAKrD,KAAO,WACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,oBAXfpR,EAAA+2B,WAeA/2B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAIkxB,oFCjBzB,MAAA7lB,EAAA5Q,EAAA,GAEA,MAAa02B,EAOT5lB,YAAYusB,EAAoBC,GAC5Bx5B,KAAKrD,KAAO,WACZqD,KAAKvB,SAAU,EACfuB,KAAKu5B,cAAgBA,EACrBv5B,KAAKw5B,WAAaA,EAGtBxsB,WACI,MACI,aACAF,EAAAzO,QAAU2B,KAAKu5B,eACf,KACAzsB,EAAAzO,QAAU2B,KAAKu5B,eACf,IACAzsB,EAAAzO,QAAU2B,KAAKw5B,YACf,MAtBZ59B,EAAAg3B,WA2BAh3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMC,EAAiBD,EAAME,MAAMC,MAC7BisB,EAAgBpsB,EAAME,MAAMC,MAC5BksB,EAAarsB,EAAME,MAAMC,MAC/BH,EAAMI,OAAOH,GAAkB,IAAIwlB,EAAS2G,EAAeC,oFChC/D,MAAa3G,EAKT7lB,cACIhN,KAAKrD,KAAO,WACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,eAXfpR,EAAAi3B,WAeAj3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAIoxB,oFCjBzB,MAAA/lB,EAAA5Q,EAAA,GAEA,MAAa42B,EAMT9lB,YAAYssB,GACRt5B,KAAKrD,KAAO,cACZqD,KAAKvB,SAAU,EACfuB,KAAKs5B,QAAUA,EAGnBtsB,WACI,MAAO,WAAaF,EAAAzO,QAAU2B,KAAKs5B,SAAW,iBAbtD19B,EAAAk3B,cAiBAl3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMmsB,EAAUnsB,EAAME,MAAMC,MAC5BH,EAAME,MAAM5L,KAAK,IAAIqxB,EAAYwG,qFCrBrC,MAAAxsB,EAAA5Q,EAAA,GAEA,MAAa62B,EAQT/lB,YAAYssB,EAAcC,EAAoBC,GAC1Cx5B,KAAKrD,KAAO,cACZqD,KAAKvB,SAAU,EACfuB,KAAKs5B,QAAUA,EACft5B,KAAKu5B,cAAgBA,EACrBv5B,KAAKw5B,WAAaA,EAGtBxsB,WACI,MACI,WACAF,EAAAzO,QAAU2B,KAAKs5B,SACf,UACAxsB,EAAAzO,QAAU2B,KAAKu5B,eACf,KACAzsB,EAAAzO,QAAU2B,KAAKu5B,eACf,IACAzsB,EAAAzO,QAAU2B,KAAKw5B,YACf,MA1BZ59B,EAAAm3B,cA+BAn3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMmsB,EAAUnsB,EAAME,MAAMC,MACtBF,EAAiBD,EAAME,MAAMC,MAC7BisB,EAAgBpsB,EAAME,MAAMC,MAC5BksB,EAAarsB,EAAME,MAAMC,MAC/BH,EAAMI,OAAOH,GAAkB,IAAI2lB,EAAYuG,EAASC,EAAeC,oFCrC3E,MAAaxG,EAKThmB,cACIhN,KAAKrD,KAAO,iBACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,iBAXfpR,EAAAo3B,iBAeAp3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAIuxB,oFCjBzB,MAAAlmB,EAAA5Q,EAAA,GAEA,MAAa+2B,EAOTjmB,YAAYysB,EAAyBC,GACjC15B,KAAKrD,KAAO,iBACZqD,KAAKvB,SAAU,EACfuB,KAAKy5B,mBAAqBA,EAC1Bz5B,KAAK05B,eAAiBA,EAG1B1sB,WACI,MACI,UACAF,EAAAzO,QAAU2B,KAAKy5B,oBACf,KACA3sB,EAAAzO,QAAU2B,KAAKy5B,oBACf,IACA3sB,EAAAzO,QAAU2B,KAAK05B,gBACf,MAtBZ99B,EAAAq3B,iBA2BAr3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMwsB,EAAiBxsB,EAAME,MAAMC,MAC7BmsB,EAAqBtsB,EAAME,MAAMC,MACjCosB,EAAiBvsB,EAAME,MAAMC,MACnCH,EAAMI,OAAOosB,GAAkB,IAAI1G,EAAewG,EAAoBC,oFCjC1E,MAAA5sB,EAAA5Q,EAAA,GAEA,MAAag3B,EAMTlmB,YAAYssB,GACRt5B,KAAKrD,KAAO,cACZqD,KAAKvB,SAAU,EACfuB,KAAKs5B,QAAUA,EAGnBtsB,WACI,MAAO,qBAAuBF,EAAAzO,QAAU2B,KAAKs5B,SAAW,WAbhE19B,EAAAs3B,cAiBAt3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMmsB,EAAUnsB,EAAME,MAAMC,MAC5BH,EAAME,MAAM5L,KAAK,IAAIyxB,EAAYoG,qFCrBrC,MAAAxsB,EAAA5Q,EAAA,GAEA,MAAai3B,EAMTnmB,YAAYgS,GACRhf,KAAKrD,KAAO,YACZqD,KAAKvB,SAAU,EACfuB,KAAK45B,OAAS5a,EAGlBhS,WACI,MAAO,mBAAqBF,EAAAzO,QAAU2B,KAAK45B,QAAU,KAb7Dh+B,EAAAu3B,YAiBAv3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM6R,EAAc7R,EAAME,MAAMC,MAChCH,EAAME,MAAM5L,KAAK,IAAI0xB,EAAUnU,qFCpBnC,MAAaoU,EAKTpmB,cACIhN,KAAKrD,KAAO,WACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,kBAXfpR,EAAAw3B,WAeAx3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI2xB,oFChBzB,MAAaC,EAKTrmB,cACIhN,KAAKrD,KAAO,YACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,mBAXfpR,EAAAy3B,YAeAz3B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI4xB,oFChBzB,MAAaC,EAKTtmB,cACIhN,KAAKrD,KAAO,SACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,gBAXfpR,EAAA03B,SAeA13B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI6xB,oFChBzB,MAAaC,EAKTvmB,cACIhN,KAAKrD,KAAO,aACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,oBAXfpR,EAAA23B,aAeA33B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI8xB,oFChBzB,MAAaC,EAKTxmB,cACIhN,KAAKrD,KAAO,WACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,kBAXfpR,EAAA43B,WAeA53B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAI+xB,oFChBzB53B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAMC,uFCFhB,MAAAlP,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAaw3B,EAOT1mB,YAAYC,EAAe6C,GACvB9P,KAAKrD,KAAO,SACZqD,KAAKvB,SAAU,EACfuB,KAAKiN,SAAWA,EAChBjN,KAAK8P,KAAOA,EAGhB9C,WACI,MAAO,UAAYF,EAAAzO,QAAU2B,KAAKiN,UAAY,OAASH,EAAAzO,QAAU2B,KAAK8P,MAAQ,KAftFlU,EAAA83B,SAmBA93B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM0sB,EAAgB1sB,EAAME,MAAMC,MAC5BwsB,EAAY3sB,EAAME,MAAMC,MAC1BlP,EAAUG,WAAWs7B,GACrB1sB,EAAMI,OAAOssB,EAAc7xB,cAAgB8xB,EAE3C3sB,EAAMoP,aAAa9a,KAAK,IAAIiyB,EAAOmG,EAAeC,qFC5B1D,MAAA17B,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEM69B,EAAe,IAAIzf,KACrB,MAAM6C,EAAgB,GAQtB,OAPA7C,EAAMY,QAAS8e,IACQ,SAAfA,EAAMr9B,MAAmBq9B,EAAM1f,MAC/B6C,EAAS1b,QAAQs4B,KAAgBC,EAAM1f,QAEvC6C,EAAS1b,KAAKu4B,KAGf7c,GAGX,MAAa8c,EAUTjtB,YAAYmQ,EAAelQ,EAAeqN,EAAY4f,EAAY9c,GAC9Dpd,KAAKrD,KAAO,cACZqD,KAAKvB,SAAU,EACfuB,KAAKiN,SAAWA,EAChBjN,KAAKk6B,MAAQA,EACbl6B,KAAKsa,MAAQA,EACbta,KAAKod,eAAiBA,EACtBpd,KAAKmd,SAAWA,EAGpBnQ,WACI,IAAImtB,EAAc,WAAan6B,KAAKk6B,MAAQ,GAI5C,OAHIl6B,KAAKiN,YAAYjN,KAAKmd,YAAcnd,KAAKmd,WAAWnd,KAAKiN,UAAUtQ,OACnEw9B,EAAcn6B,KAAKmd,WAAWnd,KAAKiN,UAAUtQ,MAE7CqD,KAAKod,eAED+c,EACAn6B,KAAKsa,MAAM3O,IAAKrN,GAAc,IAAMwO,EAAAzO,QAAUC,GAAQ,KAAK4N,KAAK,IAChE,IACAlM,KAAKod,eAAe5e,WACpB,IAIA27B,EAAcn6B,KAAKsa,MAAM3O,IAAKrN,GAAc,IAAMwO,EAAAzO,QAAUC,GAAQ,KAAK4N,KAAK,KAnC9FtQ,EAAAq+B,cAyCA,MAAarG,EAOT5mB,YAAYC,EAAeqQ,GACvBtd,KAAKrD,KAAO,QACZqD,KAAKvB,SAAU,EACfuB,KAAKiN,SAAWA,EAChBjN,KAAKsd,UAAYA,EAGrBtQ,WACI,OAAI5O,EAAUG,WAAWyB,KAAKiN,WAAajN,KAAKiN,SAASzO,aAAcwB,KAAKsd,YACpEtd,KAAKsd,YAAYtd,KAAKiN,SAASzO,YAAY8c,MACpCtb,KAAKsd,YAAYtd,KAAKiN,SAASzO,YAAY8c,MAG9C,OAASxe,OAAOwmB,KAAKtjB,KAAKsd,aAAahR,QAAQtM,KAAKiN,SAASzO,YAAc,GAI5E,WAAasO,EAAAzO,QAAU2B,KAAKiN,UAAY,KAxB3DrR,EAAAg4B,QA6BAh4B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM0sB,EAAgB1sB,EAAME,MAAMC,MAClC,GAA2B,SAAvBusB,EAAcl9B,KAAiB,CAC/B,MAAMy9B,EAAeL,KAAgBF,EAAcvf,OAC7C+f,EAAkBD,EAAaje,KAAMme,GACvCl8B,EAAUG,WAAW+7B,IAEnBC,EAAeH,EAAavc,OAC7Byc,IAAsBl8B,EAAUG,WAAW+7B,IAE5CD,GAAmBE,EAAa75B,OAAS,GACnC25B,KAAmBltB,EAAMgQ,WAC3BhQ,EAAMgQ,SAASkd,GAAmB,CAC9B19B,MAAM,EACN0gB,QAAS,GACTiG,KAAM,GACNkX,OAAQ,KAGhBrtB,EAAMgQ,SAASkd,GAAiB/W,KAAK7hB,KAAK84B,GAC1CptB,EAAME,MAAM5L,KACR,IAAIw4B,EACA,IAAM9sB,EAAMgQ,SACZkd,EACAE,EACAz9B,OAAOwmB,KAAKnW,EAAMgQ,UAAU7Q,QAAQ+tB,EAAgB77B,eAI5D2O,EAAME,MAAM5L,KAAK,IAAImyB,EAAMiG,EAAe,IAAM1sB,EAAMmQ,iBAEvD,GACoB,QAAvBuc,EAAcl9B,MACc,SAA5Bk9B,EAAc7tB,KAAKrP,MACnByB,EAAUG,WAAWs7B,EAAcpsB,OACrC,CACE,MAAM2sB,EAAeL,KAAgBF,EAAc7tB,KAAKsO,OAClD+f,EAAkBD,EAAaje,KAAMme,GACvCl8B,EAAUG,WAAW+7B,IAEnBC,EAAeH,EAAavc,OAC7Byc,IAAsBl8B,EAAUG,WAAW+7B,IAE5CD,GAAmBE,EAAa75B,OAAS,GACnC25B,KAAmBltB,EAAMgQ,WAC3BhQ,EAAMgQ,SAASkd,GAAmB,CAC9B19B,MAAM,EACN0gB,QAAS,GACTiG,KAAM,GACNkX,OAAQ,KAGhBrtB,EAAMgQ,SAASkd,GAAiB/W,KAAK7hB,KAAK84B,GAC1CptB,EAAME,MAAM5L,KACR,IAAIw4B,EACA,IAAM9sB,EAAMgQ,SACZkd,EACAE,EACAz9B,OAAOwmB,KAAKnW,EAAMgQ,UAAU7Q,QAAQ+tB,EAAgB77B,YACpDq7B,EAAcpsB,SAItBN,EAAME,MAAM5L,KAAK,IAAImyB,EAAMiG,EAAe,IAAM1sB,EAAMmQ,iBAEvD,GACoB,QAAvBuc,EAAcl9B,MACdyB,EAAUG,WAAWs7B,EAAc7tB,OACN,SAA7B6tB,EAAcpsB,MAAM9Q,KACtB,CACE,MAAMy9B,EAAeL,KAAgBF,EAAcpsB,MAAM6M,OACnD+f,EAAkBD,EAAaje,KAAMme,GACvCl8B,EAAUG,WAAW+7B,IAEnBC,EAAeH,EAAavc,OAC7Byc,IAAsBl8B,EAAUG,WAAW+7B,IAE5CD,GAAmBE,EAAa75B,OAAS,GACnC25B,KAAmBltB,EAAMgQ,WAC3BhQ,EAAMgQ,SAASkd,GAAmB,CAC9B19B,MAAM,EACN0gB,QAAS,GACTiG,KAAM,GACNkX,OAAQ,KAGhBrtB,EAAMgQ,SAASkd,GAAiB/W,KAAK7hB,KAAK84B,GAC1CptB,EAAME,MAAM5L,KACR,IAAIw4B,EACA,IAAM9sB,EAAMgQ,SACZkd,EACAE,EACAz9B,OAAOwmB,KAAKnW,EAAMgQ,UAAU7Q,QAAQ+tB,EAAgB77B,YACpDq7B,EAAc7tB,QAItBmB,EAAME,MAAM5L,KAAK,IAAImyB,EAAMiG,EAAe,IAAM1sB,EAAMmQ,iBAG1DnQ,EAAME,MAAM5L,KAAK,IAAImyB,EAAMiG,EAAe,IAAM1sB,EAAMmQ,6FCzL9D,MAAAlf,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GACA2zB,EAAA3zB,EAAA,IAEM69B,EAAe,IAAIzf,KACrB,MAAM6C,EAAgB,GAQtB,OAPA7C,EAAMY,QAAS8e,IACQ,SAAfA,EAAMr9B,MAAmBq9B,EAAM1f,MAC/B6C,EAAS1b,QAAQs4B,KAAgBC,EAAM1f,QAEvC6C,EAAS1b,KAAKu4B,KAGf7c,GAGX,MAAasd,EAWTztB,YACImQ,EACAlQ,EACAqN,EACAxK,EACAoqB,EACA9c,GAEApd,KAAKrD,KAAO,eACZqD,KAAKvB,SAAU,EACfuB,KAAKiN,SAAWA,EAChBjN,KAAKsa,MAAQA,EACbta,KAAK8P,KAAOA,EACZ9P,KAAKk6B,MAAQA,EACbl6B,KAAKod,eAAiBA,EACtBpd,KAAKmd,SAAWA,EAGpBnQ,WACI,IAAImtB,EAAc,WAAan6B,KAAKk6B,MAAQ,GAI5C,OAHIl6B,KAAKiN,YAAYjN,KAAKmd,YAAcnd,KAAKmd,WAAWnd,KAAKiN,UAAUtQ,OACnEw9B,EAAcn6B,KAAKmd,WAAWnd,KAAKiN,UAAUtQ,MAG1B,QAAnBqD,KAAK8P,KAAKnT,MACe,gBAAzBqD,KAAK8P,KAAKrC,MAAM9Q,MAChBmQ,EAAAzO,QAAU2B,KAAK8P,KAAKrC,MAAMR,YAAcH,EAAAzO,QAAU2B,KAAKiN,UAGnDktB,EACAn6B,KAAKsa,MAAM3O,IAAKrN,GAAc,IAAMwO,EAAAzO,QAAUC,GAAQ,KAAK4N,KAAK,IAChE,OACAY,EAAAzO,QAAU2B,KAAK8P,KAAK9D,MACpB,IAGe,QAAnBhM,KAAK8P,KAAKnT,MACc,gBAAxBqD,KAAK8P,KAAK9D,KAAKrP,MACfmQ,EAAAzO,QAAU2B,KAAK8P,KAAK9D,KAAKiB,YAAcH,EAAAzO,QAAU2B,KAAKiN,UAGlDktB,EACAn6B,KAAKsa,MAAM3O,IAAKrN,GAAc,IAAMwO,EAAAzO,QAAUC,GAAQ,KAAK4N,KAAK,IAChE,OACAY,EAAAzO,QAAU2B,KAAK8P,KAAKrC,OACpB,IAIA0sB,EACAn6B,KAAKsa,MAAM3O,IAAKrN,GAAc,IAAMwO,EAAAzO,QAAUC,GAAQ,KAAK4N,KAAK,IAChE,MACAY,EAAAzO,QAAU2B,KAAK8P,MACf,KAhEhBlU,EAAA6+B,eAsEA,MAAa5G,EAQT7mB,YAAYC,EAAe6C,EAAWwN,GAClCtd,KAAKrD,KAAO,SACZqD,KAAKvB,SAAU,EACfuB,KAAKiN,SAAWA,EAChBjN,KAAK8P,KAAOA,EACZ9P,KAAKsd,UAAYA,EACblf,EAAUG,WAAWyB,KAAKiN,WAAajN,KAAKiN,SAASzO,aAAcwB,KAAKsd,YACxEtd,KAAKsd,YAAYtd,KAAKiN,SAASzO,YAAY0b,MAAMzY,KAAK,IAAMzB,KAAK8P,KAAKD,OAEtEzR,EAAUG,WAAWyB,KAAKiN,WACxBjN,KAAKiN,SAASzO,aAAcwB,KAAKsd,cAEnCtd,KAAKsd,YAAYtd,KAAKiN,SAASzO,YAAc,IAAIqxB,EAAAxU,UAAS,EAAO,CAC7D,IAAMrb,KAAK8P,KAAKD,QAK5B7C,WACI,IAAI0tB,EAAe,WAAa5tB,EAAAzO,QAAU2B,KAAKiN,UAAY,IAS3D,OARI7O,EAAUG,WAAWyB,KAAKiN,WAAajN,KAAKiN,SAASzO,aAAcwB,KAAKsd,cAEpEod,EADA16B,KAAKsd,YAAYtd,KAAKiN,SAASzO,YAAY8c,MAC5Btb,KAAKsd,YAAYtd,KAAKiN,SAASzO,YAAY8c,MAGtD,OAASxe,OAAOwmB,KAAKtjB,KAAKsd,aAAahR,QAAQtM,KAAKiN,SAASzO,YAAc,IAIhE,QAAnBwB,KAAK8P,KAAKnT,MACe,UAAzBqD,KAAK8P,KAAKrC,MAAM9Q,MAChBmQ,EAAAzO,QAAU2B,KAAK8P,KAAKrC,MAAMR,YAAcH,EAAAzO,QAAU2B,KAAKiN,UAEhDytB,EAAe,OAAS5tB,EAAAzO,QAAU2B,KAAK8P,KAAK9D,MAAQ,IAExC,QAAnBhM,KAAK8P,KAAKnT,MACc,UAAxBqD,KAAK8P,KAAK9D,KAAKrP,MACfmQ,EAAAzO,QAAU2B,KAAK8P,KAAK9D,KAAKiB,YAAcH,EAAAzO,QAAU2B,KAAKiN,UAE/CytB,EAAe,OAAS5tB,EAAAzO,QAAU2B,KAAK8P,KAAKrC,OAAS,IAErDitB,EAAe,MAAQ5tB,EAAAzO,QAAU2B,KAAK8P,MAAQ,KAjDjElU,EAAAi4B,SAsDAj4B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM0sB,EAAgB1sB,EAAME,MAAMC,MAC5BwsB,EAAY3sB,EAAME,MAAMC,MAC9B,GAA2B,SAAvBusB,EAAcl9B,KAAiB,CAC/B,MAAMy9B,EAAeL,KAAgBF,EAAcvf,OAC7C+f,EAAkBD,EAAaje,KAAMme,GACvCl8B,EAAUG,WAAW+7B,IAEnBC,EAAeH,EAAavc,OAC7Byc,IAAsBl8B,EAAUG,WAAW+7B,IAE5CD,GAAmBE,EAAa75B,OAAS,GACnC25B,KAAmBltB,EAAMgQ,WAC3BhQ,EAAMgQ,SAASkd,GAAmB,CAC9B19B,MAAM,EACN0gB,QAAS,GACTiG,KAAM,GACNkX,OAAQ,KAGhBrtB,EAAMgQ,SAASkd,GAAiB/W,KAAK7hB,KAAK84B,GAC1CptB,EAAMgQ,SAASkd,GAAiBG,OAAO/4B,KAAKq4B,GAC5C3sB,EAAMoP,aAAa9a,KACf,IAAIg5B,EACA,IAAMttB,EAAMgQ,SACZkd,EACAE,EACAT,EACAh9B,OAAOwmB,KAAKnW,EAAMgQ,UAAU7Q,QAAQ+tB,EAAgB77B,eAI5D2O,EAAMoP,aAAa9a,KAAK,IAAIoyB,EAAOgG,EAAeC,EAAW,IAAM3sB,EAAMmQ,iBAE1E,GACoB,QAAvBuc,EAAcl9B,MACc,SAA5Bk9B,EAAc7tB,KAAKrP,MACnByB,EAAUG,WAAWs7B,EAAcpsB,OACrC,CACE,MAAM2sB,EAAeL,KAAgBF,EAAc7tB,KAAKsO,OAClD+f,EAAkBD,EAAaje,KAAMme,GACvCl8B,EAAUG,WAAW+7B,IAEnBC,EAAeH,EAAavc,OAC7Byc,IAAsBl8B,EAAUG,WAAW+7B,IAE5CD,GAAmBE,EAAa75B,OAAS,GACnC25B,KAAmBltB,EAAMgQ,WAC3BhQ,EAAMgQ,SAASkd,GAAmB,CAC9B19B,MAAM,EACN0gB,QAAS,GACTiG,KAAM,GACNkX,OAAQ,KAGhBrtB,EAAMgQ,SAASkd,GAAiB/W,KAAK7hB,KAAK84B,GAC1CptB,EAAMoP,aAAa9a,KACf,IAAIg5B,EACA,IAAMttB,EAAMgQ,SACZkd,EACAE,EACAT,EACAh9B,OAAOwmB,KAAKnW,EAAMgQ,UAAU7Q,QAAQ+tB,EAAgB77B,YACpDq7B,EAAcpsB,SAItBN,EAAMoP,aAAa9a,KAAK,IAAIoyB,EAAOgG,EAAeC,EAAW,IAAM3sB,EAAMmQ,iBAE1E,GACoB,QAAvBuc,EAAcl9B,MACdyB,EAAUG,WAAWs7B,EAAc7tB,OACN,SAA7B6tB,EAAcpsB,MAAM9Q,KACtB,CACE,MAAMy9B,EAAeL,KAAgBF,EAAcpsB,MAAM6M,OACnD+f,EAAkBD,EAAaje,KAAMme,GACvCl8B,EAAUG,WAAW+7B,IAEnBC,EAAeH,EAAavc,OAC7Byc,IAAsBl8B,EAAUG,WAAW+7B,IAE5CD,GAAmBE,EAAa75B,OAAS,GACnC25B,KAAmBltB,EAAMgQ,WAC3BhQ,EAAMgQ,SAASkd,GAAmB,CAC9B19B,MAAM,EACN0gB,QAAS,GACTiG,KAAM,GACNkX,OAAQ,KAGhBrtB,EAAMgQ,SAASkd,GAAiB/W,KAAK7hB,KAAK84B,GAC1CptB,EAAMoP,aAAa9a,KACf,IAAIg5B,EACA,IAAMttB,EAAMgQ,SACZkd,EACAE,EACAT,EACAh9B,OAAOwmB,KAAKnW,EAAMgQ,UAAU7Q,QAAQ+tB,EAAgB77B,YACpDq7B,EAAc7tB,QAItBmB,EAAMoP,aAAa9a,KAAK,IAAIoyB,EAAOgG,EAAeC,EAAW,IAAM3sB,EAAMmQ,iBAY7EnQ,EAAMoP,aAAa9a,KAAK,IAAIoyB,EAAOgG,EAAeC,EAAW,IAAM3sB,EAAMmQ,6FC9PjF,MAAAlf,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa43B,EAOT9mB,YAAYC,EAAe0tB,GACvB36B,KAAKrD,KAAO,OACZqD,KAAKvB,SAAU,EACfuB,KAAKiN,SAAWA,EAChBjN,KAAK2b,OAAQ,EACTgf,IACA36B,KAAK2b,OAAQ,GAIrB3O,WACI,OAAKhN,KAAK2b,MAGC,QAAU7O,EAAAzO,QAAU2B,KAAKiN,UAAY,KAFrC,mCAnBnBrR,EAAAk4B,OA0BAl4B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM2O,EAAe3O,EAAME,MAAMC,MACjC,GAAKlP,EAAUG,WAAWud,GAGnB,CACH,MAAME,EAAU7O,EAAM8O,aAChBC,EAAmBF,EAAQG,KAAMtf,GAAWA,EAAEuf,KAAON,EAAa9T,cACxE,GAAKkU,EAGE,CACH,MAAMG,EAAYL,EAAQ1P,QAAQ4P,GAC5BhP,EAAOkP,GAAK,IAAMN,EAAa9T,eAAgBmF,EAAMmP,OAgBvDnP,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAIqyB,EAAKhY,KAhB5BI,GAA8C,aAA1BA,EAAiBvf,MAItCuf,GACAG,GAAa,GACa,aAA1BH,EAAiBvf,MAEjBwQ,EAAMmP,MAAMpP,EAAOkP,GAAK,IAAMN,EAAa9T,eAAgB,EAC3DmF,EAAMiP,GAAKC,IARXlP,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAIqyB,EAAKhY,GAAc,UAPvD3O,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAIqyB,EAAKhY,GAAc,SAPnD3O,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAIqyB,EAAKhY,GAAc,qFCjCvD,MAAA1d,EAAAlC,EAAA,GAEAN,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAKrD,EAAU8O,EAAOkP,sFCFtC,MAAa4X,EAKThnB,cACIhN,KAAKrD,KAAO,QACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,iBAXfpR,EAAAo4B,QAeAp4B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAIuyB,oFChBzB,MAAaC,EAKTjnB,cACIhN,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EAGnBuO,WACI,MAAO,aAXfpR,EAAAq4B,MAeAr4B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAME,MAAM5L,KAAK,IAAIwyB,oFChBzBr4B,EAAAyC,QAAe,EAAC6O,EAAgBC,uFCDhC,MAAA/O,EAAAlC,EAAA,GAEAN,EAAAyC,QAAe,EAAC6O,EAAgBC,KACLP,SAASM,EAAOvQ,KAAKwc,QAAQ,OAAQ,IAAK,IACjEhM,EAAME,MAAM5L,KAAKrD,EAAU8O,EAAO6V,SAAUvkB,SAAS,OAAQ,sFCHjE5C,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMytB,EAAoBhuB,SAASM,EAAOvQ,KAAKwc,QAAQ,MAAO,IAAK,IAAM,EACzEhM,EAAME,MAAMwtB,UAAUD,oFCF1Bh/B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM2tB,EAAeluB,SAASM,EAAOvQ,KAAKwc,QAAQ,OAAQ,IAAK,IAC/DhM,EAAME,MAAMiD,KAAKwqB,oFCHrB,MAAAtL,EAAAtzB,EAAA,GACAyiB,EAAAziB,EAAA,GACAkC,EAAAlC,EAAA,GAEA,MAAa6+B,EAUT/tB,YAAYguB,EAAa1gB,EAAa8e,EAAmBC,GACrDr5B,KAAKrD,KAAO,MACZqD,KAAKvB,SAAU,EACfuB,KAAKg7B,OAASA,EAEVh7B,KAAKg7B,OAAOt6B,OAAS,GACrBtC,EAAUG,WAAWyB,KAAKg7B,OAAO,KACjCh7B,KAAKg7B,OAAO,GAAGx8B,SAAS,MAAOmgB,IAE/B3e,KAAKi7B,UAAatc,EAAoB3e,KAAKg7B,OAAO,GAAGx8B,SAAS,KAAK4N,MAAM,KAAK,GAC9EpM,KAAKg7B,OAAOx3B,SAEZxD,KAAKo5B,aAAep5B,KAAKq5B,cACzBr5B,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,GAEpBr5B,KAAKsa,MAAQA,EAIrBtN,WACI,OAAIhN,KAAKi7B,UAED,QAAUj7B,KAAKi7B,UAAY,IAAM,IAAIj7B,KAAKg7B,UAAWh7B,KAAKsa,OAAOpO,KAAK,MAAQ,IAG3E,OAAS,IAAIlM,KAAKg7B,UAAWh7B,KAAKsa,OAAOpO,KAAK,MAAQ,KApCzEtQ,EAAAm/B,MAyCAn/B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM+tB,EAActuB,SAASM,EAAOvQ,KAAKwc,QAAQ,MAAO,IAAK,IACvDigB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MAC3B0tB,EAAS,GACf,IAAK,IAAI5+B,EAAI,EAAGA,EAAI8+B,EAAa9+B,IAC7B4+B,EAAOv5B,KAAK0L,EAAME,MAAMC,OAE5B,GAAI0tB,EAAOt6B,OAAS,EAAG,CACnB,MAAMy6B,EAAaH,EAAO,GAAGx8B,SAAS,IAChC28B,KAAchuB,EAAMuR,SACtBvR,EAAMuR,OAAOyc,GAAc,GAC3BhuB,EAAMuR,OAAOyc,GAAYC,aAAeJ,EAAOt6B,OAAS,EACpDy6B,KAAcxc,IACdxR,EAAMuR,OAAOyc,GAAY7f,MAASqD,EAAoBwc,KAIlE,GAAI/8B,EAAUG,WAAW66B,IAAgBh7B,EAAUG,WAAW86B,GAAe,CACzE,MAAM/e,EAAQ,GACd,IACI,IAAIle,EAAIg9B,EAAYpxB,aACpB5L,EAAIg9B,EAAYn4B,IAAIo4B,GAAcrxB,aAClC5L,GAAK,GAEDA,KAAK+Q,EAAMI,OACX+M,EAAM7Y,KAAK0L,EAAMI,OAAOnR,IAExBke,EAAM7Y,KAAK,IAAI+tB,EAAAziB,MAAM3Q,IAGP,IAAlB4+B,EAAOt6B,SACD,cAAeyM,EAAMuR,SACvBvR,EAAMuR,OAAO2c,UAAY,IAE7BluB,EAAMuR,OAAO2c,UAAU55B,KAAK,CAAE6Y,WAElCnN,EAAMoP,aAAa9a,KAAK,IAAIs5B,EAAIC,EAAQ1gB,SAExCnN,EAAMoP,aAAa9a,KAAK,IAAIs5B,EAAIC,EAAQ,GAAI5B,EAAaC,qFCpFjE,MAAAvsB,EAAA5Q,EAAA,GAEA,MAAas8B,EAQTxrB,YAAYosB,EAAkBC,EAAmBh8B,GAC7C2C,KAAKrD,KAAO,SACZqD,KAAKrD,KAAO,UACZqD,KAAKvB,SAAU,EACfuB,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,EACpBr5B,KAAK3C,MAAQA,EAGjB2P,WACI,MACI,wBACAF,EAAAzO,QAAU2B,KAAKo5B,aACf,KACAtsB,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,aACAvsB,EAAAzO,QAAU2B,KAAK3C,OACf,cA3BZzB,EAAA48B,SAgCA58B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM9P,EAAQ8P,EAAME,MAAMC,MACpB8rB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MACjCH,EAAME,MAAM5L,KAAK,IAAI+2B,EAAOY,EAAaC,EAAch8B,qFCtC3D,MAAAyP,EAAA5Q,EAAA,GAEA,MAAau8B,EAYTzrB,YACIiS,EACAqa,EACAj8B,EACA+7B,EACAC,EACAiC,EACAC,GAEAv7B,KAAKrD,KAAO,OACZqD,KAAKvB,SAAU,EACfuB,KAAKif,IAAMA,EACXjf,KAAKs5B,QAAUA,EACft5B,KAAK3C,MAAQA,EACb2C,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,EACpBr5B,KAAKs7B,YAAcA,EACnBt7B,KAAKu7B,aAAeA,EAGxBvuB,WACI,MACI,QACAF,EAAAzO,QAAU2B,KAAKif,KACf,IACAnS,EAAAzO,QAAU2B,KAAKs5B,SACf,IACAxsB,EAAAzO,QAAU2B,KAAK3C,OACf,IACAyP,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,IACAvsB,EAAAzO,QAAU2B,KAAKs7B,aACf,IACAxuB,EAAAzO,QAAU2B,KAAKu7B,cACf,KAhDZ3/B,EAAA68B,OAqDA78B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM8R,EAAM9R,EAAME,MAAMC,MAClBgsB,EAAUnsB,EAAME,MAAMC,MACtBjQ,EAAQ8P,EAAME,MAAMC,MACpB8rB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MAC3BguB,EAAcnuB,EAAME,MAAMC,MAC1BiuB,EAAepuB,EAAME,MAAMC,MACjCH,EAAME,MAAM5L,KACR,IAAIg3B,EAAKxZ,EAAKqa,EAASj8B,EAAO+7B,EAAaC,EAAciC,EAAaC,qFChE9E,MAAAzuB,EAAA5Q,EAAA,GAEA,MAAaw8B,EAYT1rB,YACIiS,EACAqa,EACAj8B,EACA+7B,EACAC,EACAiC,EACAC,GAEAv7B,KAAKrD,KAAO,WACZqD,KAAKvB,SAAU,EACfuB,KAAKif,IAAMA,EACXjf,KAAKs5B,QAAUA,EACft5B,KAAK3C,MAAQA,EACb2C,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,EACpBr5B,KAAKs7B,YAAcA,EACnBt7B,KAAKu7B,aAAeA,EAGxBvuB,WACI,MACI,YACAF,EAAAzO,QAAU2B,KAAKif,KACf,IACAnS,EAAAzO,QAAU2B,KAAKs5B,SACf,IACAxsB,EAAAzO,QAAU2B,KAAK3C,OACf,IACAyP,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,IACAvsB,EAAAzO,QAAU2B,KAAKs7B,aACf,IACAxuB,EAAAzO,QAAU2B,KAAKu7B,cACf,KAhDZ3/B,EAAA88B,WAqDA98B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM8R,EAAM9R,EAAME,MAAMC,MAClBgsB,EAAUnsB,EAAME,MAAMC,MACtBjQ,EAAQ8P,EAAME,MAAMC,MACpB8rB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MAC3BguB,EAAcnuB,EAAME,MAAMC,MAC1BiuB,EAAepuB,EAAME,MAAMC,MACjCH,EAAME,MAAM5L,KACR,IAAIi3B,EAASzZ,EAAKqa,EAASj8B,EAAO+7B,EAAaC,EAAciC,EAAaC,qFChElF,MAAA/L,EAAAtzB,EAAA,GACAs/B,EAAAt/B,EAAA,IACAkC,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAay8B,EAQT3rB,YAAYsN,EAAY8e,EAAmBC,GACvCr5B,KAAKrD,KAAO,SACZqD,KAAKvB,SAAU,EACX26B,GAAeC,GACfr5B,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,GAEpBr5B,KAAKsa,MAAQA,EAIrBtN,WACI,OAAIhN,KAAKo5B,aAAep5B,KAAKq5B,aAErB,iBACAvsB,EAAAzO,QAAU2B,KAAKo5B,aACf,KACAtsB,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,MAEyB,IAAtBr5B,KAAKsa,MAAM5Z,OACX,UAEe,IAAtBV,KAAKsa,MAAM5Z,SACVtC,EAAUG,WAAWyB,KAAKsa,MAAM,KAAOta,KAAKsa,MAAM,GAAGmhB,QAE/C,UAAYz7B,KAAKsa,MAAM,GAAK,IAEb,IAAtBta,KAAKsa,MAAM5Z,QACXV,KAAKsa,MAAMa,MAAO7c,GAAcF,EAAUG,WAAWD,KACrD0B,KAAKsa,MAAM,GAAGjV,OAAO,IAEd,WAAam2B,EAAAE,MAAM17B,KAAKsa,MAAM,GAAG9b,SAAS,KAAO,KAEjD,UAAYwB,KAAKsa,MAAM3O,IAAKrN,GAAcwO,EAAAzO,QAAUC,IAAO4N,KAAK,MAAQ,MA5C3FtQ,EAAA+8B,SAiDA/8B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMisB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MAEjC,GADAH,EAAMqP,QAAS,EACXpe,EAAUG,WAAW66B,IAAgBh7B,EAAUG,WAAW86B,GAAe,CACzE,MAAM/e,EAAQ,GACd,IACI,IAAIle,EAAIg9B,EAAYpxB,aACpB5L,EAAIg9B,EAAYn4B,IAAIo4B,GAAcrxB,aAClC5L,GAAK,GAEDA,KAAK+Q,EAAMI,OACX+M,EAAM7Y,KAAK0L,EAAMI,OAAOnR,IAExBke,EAAM7Y,KAAK,IAAI+tB,EAAAziB,MAAM3Q,IAG7B+Q,EAAMoP,aAAa9a,KAAK,IAAIk3B,EAAOre,SAEnCnN,EAAMoP,aAAa9a,KAAK,IAAIk3B,EAAO,GAAIS,EAAaC,oCC3E5D,SAAgBqC,EAAMC,GAClB,MAAMC,EAAMD,EAAKn9B,WACjB,IAAIkO,EAAM,GACV,IAAK,IAAItQ,EAAI,EAAGA,EAAIw/B,EAAIl7B,QAA+B,OAArBk7B,EAAInqB,OAAOrV,EAAG,GAAaA,GAAK,EAC9DsQ,GAAOhD,OAAO2J,aAAazG,SAASgvB,EAAInqB,OAAOrV,EAAG,GAAI,KAE1D,OAAOsQ,EAWX,SAAgBmvB,EAAMC,GAClB,MAAO,eAAevvB,KAAKuvB,oDAlB/BlgC,EAAA8/B,QASA9/B,EAAAmgC,MAAA,SAAsBjsB,GAClB,OAAIA,EAAKpP,QAAU,GACRoP,EAEA,IAAIiO,OAAO,GAAKjO,EAAKpP,QAAUoP,GAI9ClU,EAAAigC,QAIAjgC,EAAAyC,QAAgByR,KACZ,GAAI+rB,EAAM/rB,GAAO,CACb,MAAMksB,EAASlsB,EAAKiF,MAAM,YAC1B,GAAsB,IAAlBinB,EAAOt7B,QAA4C,KAA5BkM,SAASovB,EAAO,GAAI,IAAY,CACvD,MAAMC,EAAyC,EAA1BrvB,SAASovB,EAAO,GAAI,IAEzC,MAAO,IADYN,EAAMM,EAAO,GAAGvqB,OAAO,EAAGwqB,IACnB,IACvB,OAAKxrB,MAAM7D,SAASkD,EAAM,KAGtBA,EAFAlD,SAASkD,EAAM,IAAItR,WAK9B,OAAOsR,mFChCf,MAAAhD,EAAA5Q,EAAA,GAEA,MAAa08B,EAWT5rB,YACIiS,EACAqa,EACAF,EACAC,EACAiC,EACAC,GAEAv7B,KAAKrD,KAAO,eACZqD,KAAKvB,SAAU,EACfuB,KAAKif,IAAMA,EACXjf,KAAKs5B,QAAUA,EACft5B,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,EACpBr5B,KAAKs7B,YAAcA,EACnBt7B,KAAKu7B,aAAeA,EAGxBvuB,WACI,MACI,gBACAF,EAAAzO,QAAU2B,KAAKif,KACf,IACAnS,EAAAzO,QAAU2B,KAAKs5B,SACf,IACAxsB,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,IACAvsB,EAAAzO,QAAU2B,KAAKs7B,aACf,IACAxuB,EAAAzO,QAAU2B,KAAKu7B,cACf,KA3CZ3/B,EAAAg9B,eAgDAh9B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM8R,EAAM9R,EAAME,MAAMC,MAClBgsB,EAAUnsB,EAAME,MAAMC,MACtB8rB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MAC3BguB,EAAcnuB,EAAME,MAAMC,MAC1BiuB,EAAepuB,EAAME,MAAMC,MACjCH,EAAME,MAAM5L,KACR,IAAIm3B,EAAa3Z,EAAKqa,EAASF,EAAaC,EAAciC,EAAaC,qFC1D/E,MAAAzuB,EAAA5Q,EAAA,GAEA,MAAa28B,EAQT7rB,YAAYosB,EAAkBC,EAAmBh8B,GAC7C2C,KAAKrD,KAAO,UACZqD,KAAKvB,SAAU,EACfuB,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,EACpBr5B,KAAK3C,MAAQA,EAGjB2P,WACI,MACI,wBACAF,EAAAzO,QAAU2B,KAAKo5B,aACf,KACAtsB,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,aACAvsB,EAAAzO,QAAU2B,KAAK3C,OACf,cA1BZzB,EAAAi9B,UA+BAj9B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM9P,EAAQ8P,EAAME,MAAMC,MACpB8rB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MACjCH,EAAME,MAAM5L,KAAK,IAAIo3B,EAAQO,EAAaC,EAAch8B,qFCrC5D,MAAAyP,EAAA5Q,EAAA,GAEA,MAAa48B,EAWT9rB,YACIiS,EACAqa,EACAF,EACAC,EACAiC,EACAC,GAEAv7B,KAAKrD,KAAO,aACZqD,KAAKvB,SAAU,EACfuB,KAAKif,IAAMA,EACXjf,KAAKs5B,QAAUA,EACft5B,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,EACpBr5B,KAAKs7B,YAAcA,EACnBt7B,KAAKu7B,aAAeA,EAGxBvuB,WACI,MACI,cACAF,EAAAzO,QAAU2B,KAAKif,KACf,IACAnS,EAAAzO,QAAU2B,KAAKs5B,SACf,IACAxsB,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,IACAvsB,EAAAzO,QAAU2B,KAAKs7B,aACf,IACAxuB,EAAAzO,QAAU2B,KAAKu7B,cACf,KA3CZ3/B,EAAAk9B,aAgDAl9B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAM8R,EAAM9R,EAAME,MAAMC,MAClBgsB,EAAUnsB,EAAME,MAAMC,MACtB8rB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MAC3BguB,EAAcnuB,EAAME,MAAMC,MAC1BiuB,EAAepuB,EAAME,MAAMC,MACjCH,EAAME,MAAM5L,KACR,IAAIq3B,EAAW7Z,EAAKqa,EAASF,EAAaC,EAAciC,EAAaC,qFC1D7E,MAAA/L,EAAAtzB,EAAA,GACAkC,EAAAlC,EAAA,GACA4Q,EAAA5Q,EAAA,GAEA,MAAa68B,EAQT/rB,YAAYsN,EAAY8e,EAAmBC,GACvCr5B,KAAKrD,KAAO,SACZqD,KAAKvB,SAAU,EACX26B,GAAeC,GACfr5B,KAAKo5B,YAAcA,EACnBp5B,KAAKq5B,aAAeA,GAEpBr5B,KAAKsa,MAAQA,EAIrBtN,WACI,OAAIhN,KAAKsa,MACE,UAAYta,KAAKsa,MAAM3O,IAAKrN,GAAcwO,EAAAzO,QAAUC,IAAO4N,KAAK,MAAQ,KAG3E,iBACAY,EAAAzO,QAAU2B,KAAKo5B,aACf,KACAtsB,EAAAzO,QAAU2B,KAAKo5B,aACf,IACAtsB,EAAAzO,QAAU2B,KAAKq5B,cACf,QA9BhBz9B,EAAAm9B,SAoCAn9B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMisB,EAAcjsB,EAAME,MAAMC,MAC1B+rB,EAAelsB,EAAME,MAAMC,MAEjC,GADAH,EAAMqP,QAAS,EACXpe,EAAUG,WAAW66B,IAAgBh7B,EAAUG,WAAW86B,GAAe,CACzE,MAAM/e,EAAQ,GACd,IACI,IAAIle,EAAIg9B,EAAYpxB,aACpB5L,EAAIg9B,EAAYn4B,IAAIo4B,GAAcrxB,aAClC5L,GAAK,GAEDA,KAAK+Q,EAAMI,OACX+M,EAAM7Y,KAAK0L,EAAMI,OAAOnR,IAExBke,EAAM7Y,KAAK,IAAI+tB,EAAAziB,MAAM3Q,IAG7B+Q,EAAMoP,aAAa9a,KAAK,IAAIs3B,EAAOze,SAEnCnN,EAAMoP,aAAa9a,KAAK,IAAIs3B,EAAO,GAAIK,EAAaC,qFC1D5D,MAAaL,EAMThsB,YAAYE,GACRlN,KAAKrD,KAAO,UACZqD,KAAKvB,SAAU,EACfuB,KAAKkN,OAASA,EAGlBF,WACI,MAAO,kCAAoChN,KAAKkN,OAAO1O,SAAS,IAAM,QAb9E5C,EAAAo9B,UAiBAp9B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5BA,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAIu3B,EAAQ9rB,EAAOA,0FCpB/C,MAAAJ,EAAA5Q,EAAA,GAEA,MAAa+8B,EAMTjsB,YAAYssB,GACRt5B,KAAKrD,KAAO,eACZqD,KAAKvB,SAAU,EACfuB,KAAKs5B,QAAUA,EAGnBtsB,WACI,MAAO,gBAAkBF,EAAAzO,QAAU2B,KAAKs5B,SAAW,MAb3D19B,EAAAq9B,eAiBAr9B,EAAAyC,QAAe,EAAC6O,EAAgBC,KAC5B,MAAMmsB,EAAUnsB,EAAME,MAAMC,MAC5BH,EAAMqP,QAAS,EACfrP,EAAMoP,aAAa9a,KAAK,IAAIw3B,EAAaK,qFCxB7C19B,EAAAyC,QAAe,EAAC69B,EAAkBxd,KAC9B,MAAMyd,EAAmBr/B,OAAOwmB,KAAK4Y,GAAavwB,IAAKhO,GAAgBu+B,EAAYv+B,IACnF,IAAIsjB,EAAS,GAiCb,OA/BAvC,EAAOxD,QAASkhB,IACZ,MAAMnB,EAAYmB,EAAMhwB,MAAM,KAAK,GAC7BiwB,EAAiBD,EAClBjjB,QAAQ8hB,EAAW,IACnBpc,UAAU,GACVhc,MAAM,GAAI,GACfoe,GAAU,SACNob,GACApb,GAAUga,EAAY,IACtBha,GAAUob,EACLjwB,MAAM,KACNT,IAAI,CAACzK,EAAW9E,KACb,MAAMkgC,EAAaH,EAAiBhgB,KAAM9R,GAAWA,EAAEiR,QAAU8gB,GACjE,OAAIE,GAAclgC,EAAIkgC,EAAWlB,aACtBl6B,EAAI,gBAAkB9E,EAEtB8E,EAAI,QAAU9E,IAG5B8P,KAAK,MACV+U,GAAU,KAEVA,GAAUmb,EAEdnb,GAAU,OAGVvC,EAAOhe,OAAS,IAChBugB,GAAU,MAGPA,mFCnCXrlB,EAAAyC,QAAgB8e,KACZ,IAAI8D,EAAS,GAab,OAXAnkB,OAAOwmB,KAAKnG,GACPU,OAAQlgB,GAAawf,EAASxf,GAAK0f,QAAQ3c,OAAS,GACpDwa,QAAQ,CAACvd,EAAailB,KACnB,MAAM2Z,EAAUpf,EAASxf,GACzBsjB,GAAU,UAAYsb,EAAQ5/B,KAAO,aACrC4/B,EAAQlf,QAAQnC,QAASshB,IACrBvb,GAAU,OAASub,EAAOh+B,WAAa,QAE3CyiB,GAAU,UAGXA,mFCdX,MAAMwb,EAAoBF,IACtB,MAAMG,EAAuB,GACvBC,EAAyB,GAC/B,IAAIC,GAAc,EAwClB,OAvCAL,EAAQjZ,KACHzF,OAAQgf,GAAsBA,EAAan8B,OAAS,GACpDwa,QAAS2hB,IAEFA,EAAan8B,OAAS,GACtBm8B,EAAa,GAAGhtB,OACf6sB,EAAWrnB,SAASwnB,EAAa,GAAGhtB,OAErC6sB,EAAWj7B,KAAKo7B,EAAa,GAAGhtB,MAEhCgtB,EAAan8B,OAAS,IAAMk8B,GAC5BA,GAAc,EACdD,EAAal7B,KACTg7B,EAAiB,CACb9/B,KAAM4/B,EAAQ5/B,KACd0gB,QAASkf,EAAQlf,QACjBiG,KAAMiZ,EAAQjZ,KAAK3X,IAAK2O,IACpBA,EAAM9W,QACC8W,IAEXkgB,OAAQ+B,EAAQ/B,WAGO,IAAxBqC,EAAan8B,QAAiBk8B,GACrCL,EAAQ/B,OAAOtf,QAAS4hB,IAChBA,EAAcjtB,OAAS8sB,EAAatnB,SAASynB,EAAcjtB,OAC3D8sB,EAAal7B,KAAKq7B,EAAcjtB,UAK1B,IAAtB6sB,EAAWh8B,QACXg8B,EAAWj7B,KAAK,WAEhB86B,EAAQlf,QAAQ3c,OAAS,GAA6B,IAAxBi8B,EAAaj8B,OAC3Ci8B,EAAal7B,KAAK86B,EAAQ5/B,KAAO,UACF,IAAxBggC,EAAaj8B,QACpBi8B,EAAal7B,KAAK,WAEf,YAAci7B,EAAWxwB,KAAK,KAAO,OAASywB,EAAazwB,KAAK,KAAO,KAGlFtQ,EAAAyC,QAAgB8e,KACZ,IAAI8D,EAAS,GAgBb,OAdAnkB,OAAOwmB,KAAKnG,GAAUjC,QAAQ,CAACvd,EAAailB,KACxC,MAAM2Z,EAAUpf,EAASxf,GACrB4+B,EAAQ5/B,KACRskB,GAAUwb,EAAiBF,GAAW,WAAaA,EAAQ5/B,KAAO,IAElEskB,GAAUwb,EAAiBF,GAAW,YAAc3Z,EAAQ,GAAK,IAErE3B,GAAU,OAGVnkB,OAAOwmB,KAAKnG,GAAUzc,OAAS,IAC/BugB,GAAU,MAGPA,mFC/DXrlB,EAAAyC,QAAgBif,KACZ,IAAI2D,EAAS,GA6Bb,OA3BAnkB,OAAOwmB,KAAKhG,GAAWpC,QAAQ,CAACvd,EAAailB,KACzC,MAAMma,EAAWzf,EAAU3f,GACrBuc,EAAQ6iB,EAAS7iB,MAClBvO,IAAKkE,GACkB,mBAATA,EACAA,IAEAA,GAGdgO,OAAQhO,GAAcA,GACN,IAAjBqK,EAAMxZ,QACNwZ,EAAMzY,KAAK,WAEXs7B,EAASzhB,MACT2F,GAAU,IAAI,IAAI+B,IAAI9I,IAAQhO,KAAK,KAAO,WAAa6wB,EAASzhB,MAAQ,KAExE2F,GAAU,IAAI,IAAI+B,IAAI9I,IAAQhO,KAAK,KAAO,QAAU0W,EAAQ,GAAGpkB,WAAa,IAC5EokB,KAEJ3B,GAAU,OAGVnkB,OAAOwmB,KAAKhG,GAAW5c,OAAS,IAChCugB,GAAU,MAGPA,mFC9BX,MAAAsB,EAAArmB,EAAA,IACA8d,EAAA9d,EAAA,GAEAN,EAAAyC,QAAe,EAAC2c,EAAsBgiB,KAClC,IAAI/b,EAAS,GAEb,GADAA,GAAU,YACNjG,KAAgBhB,EAAgB,CAChC,MAAMkD,EAAgBlD,EAAuBgB,GACvCiiB,EAAmB/f,EAAa9Q,MAAM,KAAK,GAC3C8wB,EAAwBhgB,EACzB/D,QAAQ8jB,EAAkB,IAC1Bpe,UAAU,GACVhc,MAAM,GAAI,GACXq6B,GACAjc,GAAUgc,EAAmB,IAC7Bhc,GAAUic,EACL9wB,MAAM,KACNT,IAAI,CAACzK,EAAW9E,IAAc8E,EAAI,QAAU9E,GAC5C8P,KAAK,MACV+U,GAAU,KAEVA,GAAU/D,OAGd+D,GAAUjG,EAAe,KAe7B,OAbAiG,GAAU,IAAM+b,EAAiBpiB,WAC7BoiB,EAAiBniB,WACjBoG,GAAU,SAEV+b,EAAiBriB,UACjBsG,GAAU,YAEV+b,EAAiB3iB,QAAQ3Z,OAAS,IAClCugB,GAAU,aAAe+b,EAAiB3iB,QAAQnO,KAAK,MAAQ,KAEnE+U,GAAU,OACVA,GAAUsB,EAAAlkB,QAAsB2+B,EAAiB1iB,MAAO,GACxD2G,GAAU,yFCtCd,MAAqBkc,EAGjBnwB,cACIhN,KAAKo9B,SAAW,GAGpBpwB,KAAK1O,GACD,GAAI0B,KAAKo9B,SAAS18B,QAAU,KACxB,MAAM,IAAIkE,MAAM,kBAEhB5E,KAAKo9B,SAAS74B,QAAQjG,GAI9B0O,MACI,GAA6B,IAAzBhN,KAAKo9B,SAAS18B,OACd,MAAM,IAAIkE,MAAM,wBAEhB,OAAO5E,KAAKo9B,SAAS55B,QAI7BwJ,UAAUmsB,GACN,GAAIA,EAAW,GAAKA,EAAW,GAC3B,MAAM,IAAIv0B,MAAM,kDACb,KAAMu0B,KAAYn5B,KAAKo9B,UAC1B,MAAM,IAAIx4B,MACN,0EAGJ5E,KAAKyB,KAAKzB,KAAKo9B,SAASjE,IAIhCnsB,KAAKqwB,GACD,GAAIA,EAAiB,GAAKA,EAAiB,GACvC,MAAM,IAAIz4B,MAAM,2CACb,KAAMy4B,KAAkBr9B,KAAKo9B,UAChC,MAAM,IAAIx4B,MAAM,mEACb,CACH,MAAM04B,EAAat9B,KAAKo9B,SAAS,GAC3BG,EAAcv9B,KAAKo9B,SAASC,GAClCr9B,KAAKo9B,SAAS,GAAKG,EACnBv9B,KAAKo9B,SAASC,GAAkBC,GAIxCtwB,QACI,MAAMK,EAAQ,IAAI8vB,EAElB,OADA9vB,EAAM+vB,SAAW,IAAIp9B,KAAKo9B,UACnB/vB,EAGXL,QACIhN,KAAKo9B,SAAW,IAvDxBxhC,EAAAyC,QAAA8+B","file":"EVM.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"EVM\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"EVM\"] = factory();\n\telse\n\t\troot[\"EVM\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 16);\n","import * as BigNumber from '../../node_modules/big-integer';\r\n\r\nexport default (item: any) => {\r\n    if (BigNumber.isInstance(item)) {\r\n        return item.toString(16);\r\n    } else if (!item.wrapped) {\r\n        return item.toString();\r\n    } else {\r\n        return '(' + item.toString() + ')';\r\n    }\r\n};\r\n","var bigInt = (function (undefined) {\r\n    \"use strict\";\r\n\r\n    var BASE = 1e7,\r\n        LOG_BASE = 7,\r\n        MAX_INT = 9007199254740992,\r\n        MAX_INT_ARR = smallToArray(MAX_INT),\r\n        DEFAULT_ALPHABET = \"0123456789abcdefghijklmnopqrstuvwxyz\";\r\n\r\n    var supportsNativeBigInt = typeof BigInt === \"function\";\r\n\r\n    function Integer(v, radix, alphabet, caseSensitive) {\r\n        if (typeof v === \"undefined\") return Integer[0];\r\n        if (typeof radix !== \"undefined\") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);\r\n        return parseValue(v);\r\n    }\r\n\r\n    function BigInteger(value, sign) {\r\n        this.value = value;\r\n        this.sign = sign;\r\n        this.isSmall = false;\r\n    }\r\n    BigInteger.prototype = Object.create(Integer.prototype);\r\n\r\n    function SmallInteger(value) {\r\n        this.value = value;\r\n        this.sign = value < 0;\r\n        this.isSmall = true;\r\n    }\r\n    SmallInteger.prototype = Object.create(Integer.prototype);\r\n\r\n    function NativeBigInt(value) {\r\n        this.value = value;\r\n    }\r\n    NativeBigInt.prototype = Object.create(Integer.prototype);\r\n\r\n    function isPrecise(n) {\r\n        return -MAX_INT < n && n < MAX_INT;\r\n    }\r\n\r\n    function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes\r\n        if (n < 1e7)\r\n            return [n];\r\n        if (n < 1e14)\r\n            return [n % 1e7, Math.floor(n / 1e7)];\r\n        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];\r\n    }\r\n\r\n    function arrayToSmall(arr) { // If BASE changes this function may need to change\r\n        trim(arr);\r\n        var length = arr.length;\r\n        if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {\r\n            switch (length) {\r\n                case 0: return 0;\r\n                case 1: return arr[0];\r\n                case 2: return arr[0] + arr[1] * BASE;\r\n                default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;\r\n            }\r\n        }\r\n        return arr;\r\n    }\r\n\r\n    function trim(v) {\r\n        var i = v.length;\r\n        while (v[--i] === 0);\r\n        v.length = i + 1;\r\n    }\r\n\r\n    function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger\r\n        var x = new Array(length);\r\n        var i = -1;\r\n        while (++i < length) {\r\n            x[i] = 0;\r\n        }\r\n        return x;\r\n    }\r\n\r\n    function truncate(n) {\r\n        if (n > 0) return Math.floor(n);\r\n        return Math.ceil(n);\r\n    }\r\n\r\n    function add(a, b) { // assumes a and b are arrays with a.length >= b.length\r\n        var l_a = a.length,\r\n            l_b = b.length,\r\n            r = new Array(l_a),\r\n            carry = 0,\r\n            base = BASE,\r\n            sum, i;\r\n        for (i = 0; i < l_b; i++) {\r\n            sum = a[i] + b[i] + carry;\r\n            carry = sum >= base ? 1 : 0;\r\n            r[i] = sum - carry * base;\r\n        }\r\n        while (i < l_a) {\r\n            sum = a[i] + carry;\r\n            carry = sum === base ? 1 : 0;\r\n            r[i++] = sum - carry * base;\r\n        }\r\n        if (carry > 0) r.push(carry);\r\n        return r;\r\n    }\r\n\r\n    function addAny(a, b) {\r\n        if (a.length >= b.length) return add(a, b);\r\n        return add(b, a);\r\n    }\r\n\r\n    function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            base = BASE,\r\n            sum, i;\r\n        for (i = 0; i < l; i++) {\r\n            sum = a[i] - base + carry;\r\n            carry = Math.floor(sum / base);\r\n            r[i] = sum - carry * base;\r\n            carry += 1;\r\n        }\r\n        while (carry > 0) {\r\n            r[i++] = carry % base;\r\n            carry = Math.floor(carry / base);\r\n        }\r\n        return r;\r\n    }\r\n\r\n    BigInteger.prototype.add = function (v) {\r\n        var n = parseValue(v);\r\n        if (this.sign !== n.sign) {\r\n            return this.subtract(n.negate());\r\n        }\r\n        var a = this.value, b = n.value;\r\n        if (n.isSmall) {\r\n            return new BigInteger(addSmall(a, Math.abs(b)), this.sign);\r\n        }\r\n        return new BigInteger(addAny(a, b), this.sign);\r\n    };\r\n    BigInteger.prototype.plus = BigInteger.prototype.add;\r\n\r\n    SmallInteger.prototype.add = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value;\r\n        if (a < 0 !== n.sign) {\r\n            return this.subtract(n.negate());\r\n        }\r\n        var b = n.value;\r\n        if (n.isSmall) {\r\n            if (isPrecise(a + b)) return new SmallInteger(a + b);\r\n            b = smallToArray(Math.abs(b));\r\n        }\r\n        return new BigInteger(addSmall(b, Math.abs(a)), a < 0);\r\n    };\r\n    SmallInteger.prototype.plus = SmallInteger.prototype.add;\r\n\r\n    NativeBigInt.prototype.add = function (v) {\r\n        return new NativeBigInt(this.value + parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.plus = NativeBigInt.prototype.add;\r\n\r\n    function subtract(a, b) { // assumes a and b are arrays with a >= b\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            r = new Array(a_l),\r\n            borrow = 0,\r\n            base = BASE,\r\n            i, difference;\r\n        for (i = 0; i < b_l; i++) {\r\n            difference = a[i] - borrow - b[i];\r\n            if (difference < 0) {\r\n                difference += base;\r\n                borrow = 1;\r\n            } else borrow = 0;\r\n            r[i] = difference;\r\n        }\r\n        for (i = b_l; i < a_l; i++) {\r\n            difference = a[i] - borrow;\r\n            if (difference < 0) difference += base;\r\n            else {\r\n                r[i++] = difference;\r\n                break;\r\n            }\r\n            r[i] = difference;\r\n        }\r\n        for (; i < a_l; i++) {\r\n            r[i] = a[i];\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    function subtractAny(a, b, sign) {\r\n        var value;\r\n        if (compareAbs(a, b) >= 0) {\r\n            value = subtract(a, b);\r\n        } else {\r\n            value = subtract(b, a);\r\n            sign = !sign;\r\n        }\r\n        value = arrayToSmall(value);\r\n        if (typeof value === \"number\") {\r\n            if (sign) value = -value;\r\n            return new SmallInteger(value);\r\n        }\r\n        return new BigInteger(value, sign);\r\n    }\r\n\r\n    function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            carry = -b,\r\n            base = BASE,\r\n            i, difference;\r\n        for (i = 0; i < l; i++) {\r\n            difference = a[i] + carry;\r\n            carry = Math.floor(difference / base);\r\n            difference %= base;\r\n            r[i] = difference < 0 ? difference + base : difference;\r\n        }\r\n        r = arrayToSmall(r);\r\n        if (typeof r === \"number\") {\r\n            if (sign) r = -r;\r\n            return new SmallInteger(r);\r\n        } return new BigInteger(r, sign);\r\n    }\r\n\r\n    BigInteger.prototype.subtract = function (v) {\r\n        var n = parseValue(v);\r\n        if (this.sign !== n.sign) {\r\n            return this.add(n.negate());\r\n        }\r\n        var a = this.value, b = n.value;\r\n        if (n.isSmall)\r\n            return subtractSmall(a, Math.abs(b), this.sign);\r\n        return subtractAny(a, b, this.sign);\r\n    };\r\n    BigInteger.prototype.minus = BigInteger.prototype.subtract;\r\n\r\n    SmallInteger.prototype.subtract = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value;\r\n        if (a < 0 !== n.sign) {\r\n            return this.add(n.negate());\r\n        }\r\n        var b = n.value;\r\n        if (n.isSmall) {\r\n            return new SmallInteger(a - b);\r\n        }\r\n        return subtractSmall(b, Math.abs(a), a >= 0);\r\n    };\r\n    SmallInteger.prototype.minus = SmallInteger.prototype.subtract;\r\n\r\n    NativeBigInt.prototype.subtract = function (v) {\r\n        return new NativeBigInt(this.value - parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;\r\n\r\n    BigInteger.prototype.negate = function () {\r\n        return new BigInteger(this.value, !this.sign);\r\n    };\r\n    SmallInteger.prototype.negate = function () {\r\n        var sign = this.sign;\r\n        var small = new SmallInteger(-this.value);\r\n        small.sign = !sign;\r\n        return small;\r\n    };\r\n    NativeBigInt.prototype.negate = function () {\r\n        return new NativeBigInt(-this.value);\r\n    }\r\n\r\n    BigInteger.prototype.abs = function () {\r\n        return new BigInteger(this.value, false);\r\n    };\r\n    SmallInteger.prototype.abs = function () {\r\n        return new SmallInteger(Math.abs(this.value));\r\n    };\r\n    NativeBigInt.prototype.abs = function () {\r\n        return new NativeBigInt(this.value >= 0 ? this.value : -this.value);\r\n    }\r\n\r\n\r\n    function multiplyLong(a, b) {\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            l = a_l + b_l,\r\n            r = createArray(l),\r\n            base = BASE,\r\n            product, carry, i, a_i, b_j;\r\n        for (i = 0; i < a_l; ++i) {\r\n            a_i = a[i];\r\n            for (var j = 0; j < b_l; ++j) {\r\n                b_j = b[j];\r\n                product = a_i * b_j + r[i + j];\r\n                carry = Math.floor(product / base);\r\n                r[i + j] = product - carry * base;\r\n                r[i + j + 1] += carry;\r\n            }\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            base = BASE,\r\n            carry = 0,\r\n            product, i;\r\n        for (i = 0; i < l; i++) {\r\n            product = a[i] * b + carry;\r\n            carry = Math.floor(product / base);\r\n            r[i] = product - carry * base;\r\n        }\r\n        while (carry > 0) {\r\n            r[i++] = carry % base;\r\n            carry = Math.floor(carry / base);\r\n        }\r\n        return r;\r\n    }\r\n\r\n    function shiftLeft(x, n) {\r\n        var r = [];\r\n        while (n-- > 0) r.push(0);\r\n        return r.concat(x);\r\n    }\r\n\r\n    function multiplyKaratsuba(x, y) {\r\n        var n = Math.max(x.length, y.length);\r\n\r\n        if (n <= 30) return multiplyLong(x, y);\r\n        n = Math.ceil(n / 2);\r\n\r\n        var b = x.slice(n),\r\n            a = x.slice(0, n),\r\n            d = y.slice(n),\r\n            c = y.slice(0, n);\r\n\r\n        var ac = multiplyKaratsuba(a, c),\r\n            bd = multiplyKaratsuba(b, d),\r\n            abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));\r\n\r\n        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));\r\n        trim(product);\r\n        return product;\r\n    }\r\n\r\n    // The following function is derived from a surface fit of a graph plotting the performance difference\r\n    // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.\r\n    function useKaratsuba(l1, l2) {\r\n        return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;\r\n    }\r\n\r\n    BigInteger.prototype.multiply = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value, b = n.value,\r\n            sign = this.sign !== n.sign,\r\n            abs;\r\n        if (n.isSmall) {\r\n            if (b === 0) return Integer[0];\r\n            if (b === 1) return this;\r\n            if (b === -1) return this.negate();\r\n            abs = Math.abs(b);\r\n            if (abs < BASE) {\r\n                return new BigInteger(multiplySmall(a, abs), sign);\r\n            }\r\n            b = smallToArray(abs);\r\n        }\r\n        if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes\r\n            return new BigInteger(multiplyKaratsuba(a, b), sign);\r\n        return new BigInteger(multiplyLong(a, b), sign);\r\n    };\r\n\r\n    BigInteger.prototype.times = BigInteger.prototype.multiply;\r\n\r\n    function multiplySmallAndArray(a, b, sign) { // a >= 0\r\n        if (a < BASE) {\r\n            return new BigInteger(multiplySmall(b, a), sign);\r\n        }\r\n        return new BigInteger(multiplyLong(b, smallToArray(a)), sign);\r\n    }\r\n    SmallInteger.prototype._multiplyBySmall = function (a) {\r\n        if (isPrecise(a.value * this.value)) {\r\n            return new SmallInteger(a.value * this.value);\r\n        }\r\n        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);\r\n    };\r\n    BigInteger.prototype._multiplyBySmall = function (a) {\r\n        if (a.value === 0) return Integer[0];\r\n        if (a.value === 1) return this;\r\n        if (a.value === -1) return this.negate();\r\n        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);\r\n    };\r\n    SmallInteger.prototype.multiply = function (v) {\r\n        return parseValue(v)._multiplyBySmall(this);\r\n    };\r\n    SmallInteger.prototype.times = SmallInteger.prototype.multiply;\r\n\r\n    NativeBigInt.prototype.multiply = function (v) {\r\n        return new NativeBigInt(this.value * parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;\r\n\r\n    function square(a) {\r\n        //console.assert(2 * BASE * BASE < MAX_INT);\r\n        var l = a.length,\r\n            r = createArray(l + l),\r\n            base = BASE,\r\n            product, carry, i, a_i, a_j;\r\n        for (i = 0; i < l; i++) {\r\n            a_i = a[i];\r\n            carry = 0 - a_i * a_i;\r\n            for (var j = i; j < l; j++) {\r\n                a_j = a[j];\r\n                product = 2 * (a_i * a_j) + r[i + j] + carry;\r\n                carry = Math.floor(product / base);\r\n                r[i + j] = product - carry * base;\r\n            }\r\n            r[i + l] = carry;\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    BigInteger.prototype.square = function () {\r\n        return new BigInteger(square(this.value), false);\r\n    };\r\n\r\n    SmallInteger.prototype.square = function () {\r\n        var value = this.value * this.value;\r\n        if (isPrecise(value)) return new SmallInteger(value);\r\n        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);\r\n    };\r\n\r\n    NativeBigInt.prototype.square = function (v) {\r\n        return new NativeBigInt(this.value * this.value);\r\n    }\r\n\r\n    function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            base = BASE,\r\n            result = createArray(b.length),\r\n            divisorMostSignificantDigit = b[b_l - 1],\r\n            // normalization\r\n            lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),\r\n            remainder = multiplySmall(a, lambda),\r\n            divisor = multiplySmall(b, lambda),\r\n            quotientDigit, shift, carry, borrow, i, l, q;\r\n        if (remainder.length <= a_l) remainder.push(0);\r\n        divisor.push(0);\r\n        divisorMostSignificantDigit = divisor[b_l - 1];\r\n        for (shift = a_l - b_l; shift >= 0; shift--) {\r\n            quotientDigit = base - 1;\r\n            if (remainder[shift + b_l] !== divisorMostSignificantDigit) {\r\n                quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);\r\n            }\r\n            // quotientDigit <= base - 1\r\n            carry = 0;\r\n            borrow = 0;\r\n            l = divisor.length;\r\n            for (i = 0; i < l; i++) {\r\n                carry += quotientDigit * divisor[i];\r\n                q = Math.floor(carry / base);\r\n                borrow += remainder[shift + i] - (carry - q * base);\r\n                carry = q;\r\n                if (borrow < 0) {\r\n                    remainder[shift + i] = borrow + base;\r\n                    borrow = -1;\r\n                } else {\r\n                    remainder[shift + i] = borrow;\r\n                    borrow = 0;\r\n                }\r\n            }\r\n            while (borrow !== 0) {\r\n                quotientDigit -= 1;\r\n                carry = 0;\r\n                for (i = 0; i < l; i++) {\r\n                    carry += remainder[shift + i] - base + divisor[i];\r\n                    if (carry < 0) {\r\n                        remainder[shift + i] = carry + base;\r\n                        carry = 0;\r\n                    } else {\r\n                        remainder[shift + i] = carry;\r\n                        carry = 1;\r\n                    }\r\n                }\r\n                borrow += carry;\r\n            }\r\n            result[shift] = quotientDigit;\r\n        }\r\n        // denormalization\r\n        remainder = divModSmall(remainder, lambda)[0];\r\n        return [arrayToSmall(result), arrayToSmall(remainder)];\r\n    }\r\n\r\n    function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/\r\n        // Performs faster than divMod1 on larger input sizes.\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            result = [],\r\n            part = [],\r\n            base = BASE,\r\n            guess, xlen, highx, highy, check;\r\n        while (a_l) {\r\n            part.unshift(a[--a_l]);\r\n            trim(part);\r\n            if (compareAbs(part, b) < 0) {\r\n                result.push(0);\r\n                continue;\r\n            }\r\n            xlen = part.length;\r\n            highx = part[xlen - 1] * base + part[xlen - 2];\r\n            highy = b[b_l - 1] * base + b[b_l - 2];\r\n            if (xlen > b_l) {\r\n                highx = (highx + 1) * base;\r\n            }\r\n            guess = Math.ceil(highx / highy);\r\n            do {\r\n                check = multiplySmall(b, guess);\r\n                if (compareAbs(check, part) <= 0) break;\r\n                guess--;\r\n            } while (guess);\r\n            result.push(guess);\r\n            part = subtract(part, check);\r\n        }\r\n        result.reverse();\r\n        return [arrayToSmall(result), arrayToSmall(part)];\r\n    }\r\n\r\n    function divModSmall(value, lambda) {\r\n        var length = value.length,\r\n            quotient = createArray(length),\r\n            base = BASE,\r\n            i, q, remainder, divisor;\r\n        remainder = 0;\r\n        for (i = length - 1; i >= 0; --i) {\r\n            divisor = remainder * base + value[i];\r\n            q = truncate(divisor / lambda);\r\n            remainder = divisor - q * lambda;\r\n            quotient[i] = q | 0;\r\n        }\r\n        return [quotient, remainder | 0];\r\n    }\r\n\r\n    function divModAny(self, v) {\r\n        var value, n = parseValue(v);\r\n        if (supportsNativeBigInt) {\r\n            return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];\r\n        }\r\n        var a = self.value, b = n.value;\r\n        var quotient;\r\n        if (b === 0) throw new Error(\"Cannot divide by zero\");\r\n        if (self.isSmall) {\r\n            if (n.isSmall) {\r\n                return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];\r\n            }\r\n            return [Integer[0], self];\r\n        }\r\n        if (n.isSmall) {\r\n            if (b === 1) return [self, Integer[0]];\r\n            if (b == -1) return [self.negate(), Integer[0]];\r\n            var abs = Math.abs(b);\r\n            if (abs < BASE) {\r\n                value = divModSmall(a, abs);\r\n                quotient = arrayToSmall(value[0]);\r\n                var remainder = value[1];\r\n                if (self.sign) remainder = -remainder;\r\n                if (typeof quotient === \"number\") {\r\n                    if (self.sign !== n.sign) quotient = -quotient;\r\n                    return [new SmallInteger(quotient), new SmallInteger(remainder)];\r\n                }\r\n                return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];\r\n            }\r\n            b = smallToArray(abs);\r\n        }\r\n        var comparison = compareAbs(a, b);\r\n        if (comparison === -1) return [Integer[0], self];\r\n        if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];\r\n\r\n        // divMod1 is faster on smaller input sizes\r\n        if (a.length + b.length <= 200)\r\n            value = divMod1(a, b);\r\n        else value = divMod2(a, b);\r\n\r\n        quotient = value[0];\r\n        var qSign = self.sign !== n.sign,\r\n            mod = value[1],\r\n            mSign = self.sign;\r\n        if (typeof quotient === \"number\") {\r\n            if (qSign) quotient = -quotient;\r\n            quotient = new SmallInteger(quotient);\r\n        } else quotient = new BigInteger(quotient, qSign);\r\n        if (typeof mod === \"number\") {\r\n            if (mSign) mod = -mod;\r\n            mod = new SmallInteger(mod);\r\n        } else mod = new BigInteger(mod, mSign);\r\n        return [quotient, mod];\r\n    }\r\n\r\n    BigInteger.prototype.divmod = function (v) {\r\n        var result = divModAny(this, v);\r\n        return {\r\n            quotient: result[0],\r\n            remainder: result[1]\r\n        };\r\n    };\r\n    NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;\r\n\r\n\r\n    BigInteger.prototype.divide = function (v) {\r\n        return divModAny(this, v)[0];\r\n    };\r\n    NativeBigInt.prototype.over = NativeBigInt.prototype.divide = SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;\r\n\r\n    BigInteger.prototype.mod = function (v) {\r\n        return divModAny(this, v)[1];\r\n    };\r\n    NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;\r\n\r\n    BigInteger.prototype.pow = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value,\r\n            value, x, y;\r\n        if (b === 0) return Integer[1];\r\n        if (a === 0) return Integer[0];\r\n        if (a === 1) return Integer[1];\r\n        if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];\r\n        if (n.sign) {\r\n            return Integer[0];\r\n        }\r\n        if (!n.isSmall) throw new Error(\"The exponent \" + n.toString() + \" is too large.\");\r\n        if (this.isSmall) {\r\n            if (isPrecise(value = Math.pow(a, b)))\r\n                return new SmallInteger(truncate(value));\r\n        }\r\n        x = this;\r\n        y = Integer[1];\r\n        while (true) {\r\n            if (b & 1 === 1) {\r\n                y = y.times(x);\r\n                --b;\r\n            }\r\n            if (b === 0) break;\r\n            b /= 2;\r\n            x = x.square();\r\n        }\r\n        return y;\r\n    };\r\n    SmallInteger.prototype.pow = BigInteger.prototype.pow;\r\n\r\n    var pow;\r\n    if (supportsNativeBigInt) {\r\n        // forced to use eval because ** is a syntax error on pre-ECMAScript2017 environments.\r\n        pow = eval(\"(a,b)=>a**b\");\r\n    }\r\n\r\n    NativeBigInt.prototype.pow = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value, b = n.value;\r\n        if (b === BigInt(0)) return Integer[1];\r\n        if (a === BigInt(0)) return Integer[0];\r\n        if (a === BigInt(1)) return Integer[1];\r\n        if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];\r\n        if (n.isNegative()) return new NativeBigInt(BigInt(0));\r\n        return new NativeBigInt(pow(a, b));\r\n    }\r\n\r\n    BigInteger.prototype.modPow = function (exp, mod) {\r\n        exp = parseValue(exp);\r\n        mod = parseValue(mod);\r\n        if (mod.isZero()) throw new Error(\"Cannot take modPow with modulus 0\");\r\n        var r = Integer[1],\r\n            base = this.mod(mod);\r\n        while (exp.isPositive()) {\r\n            if (base.isZero()) return Integer[0];\r\n            if (exp.isOdd()) r = r.multiply(base).mod(mod);\r\n            exp = exp.divide(2);\r\n            base = base.square().mod(mod);\r\n        }\r\n        return r;\r\n    };\r\n    NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;\r\n\r\n    function compareAbs(a, b) {\r\n        if (a.length !== b.length) {\r\n            return a.length > b.length ? 1 : -1;\r\n        }\r\n        for (var i = a.length - 1; i >= 0; i--) {\r\n            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;\r\n        }\r\n        return 0;\r\n    }\r\n\r\n    BigInteger.prototype.compareAbs = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (n.isSmall) return 1;\r\n        return compareAbs(a, b);\r\n    };\r\n    SmallInteger.prototype.compareAbs = function (v) {\r\n        var n = parseValue(v),\r\n            a = Math.abs(this.value),\r\n            b = n.value;\r\n        if (n.isSmall) {\r\n            b = Math.abs(b);\r\n            return a === b ? 0 : a > b ? 1 : -1;\r\n        }\r\n        return -1;\r\n    };\r\n    NativeBigInt.prototype.compareAbs = function (v) {\r\n        var a = this.value;\r\n        var b = parseValue(v).value;\r\n        a = a >= 0 ? a : -a;\r\n        b = b >= 0 ? b : -b;\r\n        return a === b ? 0 : a > b ? 1 : -1;\r\n    }\r\n\r\n    BigInteger.prototype.compare = function (v) {\r\n        // See discussion about comparison with Infinity:\r\n        // https://github.com/peterolson/BigInteger.js/issues/61\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (this.sign !== n.sign) {\r\n            return n.sign ? 1 : -1;\r\n        }\r\n        if (n.isSmall) {\r\n            return this.sign ? -1 : 1;\r\n        }\r\n        return compareAbs(a, b) * (this.sign ? -1 : 1);\r\n    };\r\n    BigInteger.prototype.compareTo = BigInteger.prototype.compare;\r\n\r\n    SmallInteger.prototype.compare = function (v) {\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (n.isSmall) {\r\n            return a == b ? 0 : a > b ? 1 : -1;\r\n        }\r\n        if (a < 0 !== n.sign) {\r\n            return a < 0 ? -1 : 1;\r\n        }\r\n        return a < 0 ? 1 : -1;\r\n    };\r\n    SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;\r\n\r\n    NativeBigInt.prototype.compare = function (v) {\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n        var a = this.value;\r\n        var b = parseValue(v).value;\r\n        return a === b ? 0 : a > b ? 1 : -1;\r\n    }\r\n    NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;\r\n\r\n    BigInteger.prototype.equals = function (v) {\r\n        return this.compare(v) === 0;\r\n    };\r\n    NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;\r\n\r\n    BigInteger.prototype.notEquals = function (v) {\r\n        return this.compare(v) !== 0;\r\n    };\r\n    NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;\r\n\r\n    BigInteger.prototype.greater = function (v) {\r\n        return this.compare(v) > 0;\r\n    };\r\n    NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;\r\n\r\n    BigInteger.prototype.lesser = function (v) {\r\n        return this.compare(v) < 0;\r\n    };\r\n    NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;\r\n\r\n    BigInteger.prototype.greaterOrEquals = function (v) {\r\n        return this.compare(v) >= 0;\r\n    };\r\n    NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;\r\n\r\n    BigInteger.prototype.lesserOrEquals = function (v) {\r\n        return this.compare(v) <= 0;\r\n    };\r\n    NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;\r\n\r\n    BigInteger.prototype.isEven = function () {\r\n        return (this.value[0] & 1) === 0;\r\n    };\r\n    SmallInteger.prototype.isEven = function () {\r\n        return (this.value & 1) === 0;\r\n    };\r\n    NativeBigInt.prototype.isEven = function () {\r\n        return (this.value & BigInt(1)) === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isOdd = function () {\r\n        return (this.value[0] & 1) === 1;\r\n    };\r\n    SmallInteger.prototype.isOdd = function () {\r\n        return (this.value & 1) === 1;\r\n    };\r\n    NativeBigInt.prototype.isOdd = function () {\r\n        return (this.value & BigInt(1)) === BigInt(1);\r\n    }\r\n\r\n    BigInteger.prototype.isPositive = function () {\r\n        return !this.sign;\r\n    };\r\n    SmallInteger.prototype.isPositive = function () {\r\n        return this.value > 0;\r\n    };\r\n    NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;\r\n\r\n    BigInteger.prototype.isNegative = function () {\r\n        return this.sign;\r\n    };\r\n    SmallInteger.prototype.isNegative = function () {\r\n        return this.value < 0;\r\n    };\r\n    NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;\r\n\r\n    BigInteger.prototype.isUnit = function () {\r\n        return false;\r\n    };\r\n    SmallInteger.prototype.isUnit = function () {\r\n        return Math.abs(this.value) === 1;\r\n    };\r\n    NativeBigInt.prototype.isUnit = function () {\r\n        return this.abs().value === BigInt(1);\r\n    }\r\n\r\n    BigInteger.prototype.isZero = function () {\r\n        return false;\r\n    };\r\n    SmallInteger.prototype.isZero = function () {\r\n        return this.value === 0;\r\n    };\r\n    NativeBigInt.prototype.isZero = function () {\r\n        return this.value === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isDivisibleBy = function (v) {\r\n        var n = parseValue(v);\r\n        if (n.isZero()) return false;\r\n        if (n.isUnit()) return true;\r\n        if (n.compareAbs(2) === 0) return this.isEven();\r\n        return this.mod(n).isZero();\r\n    };\r\n    NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;\r\n\r\n    function isBasicPrime(v) {\r\n        var n = v.abs();\r\n        if (n.isUnit()) return false;\r\n        if (n.equals(2) || n.equals(3) || n.equals(5)) return true;\r\n        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;\r\n        if (n.lesser(49)) return true;\r\n        // we don't know if it's prime: let the other functions figure it out\r\n    }\r\n\r\n    function millerRabinTest(n, a) {\r\n        var nPrev = n.prev(),\r\n            b = nPrev,\r\n            r = 0,\r\n            d, t, i, x;\r\n        while (b.isEven()) b = b.divide(2), r++;\r\n        next: for (i = 0; i < a.length; i++) {\r\n            if (n.lesser(a[i])) continue;\r\n            x = bigInt(a[i]).modPow(b, n);\r\n            if (x.isUnit() || x.equals(nPrev)) continue;\r\n            for (d = r - 1; d != 0; d--) {\r\n                x = x.square().mod(n);\r\n                if (x.isUnit()) return false;\r\n                if (x.equals(nPrev)) continue next;\r\n            }\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    // Set \"strict\" to true to force GRH-supported lower bound of 2*log(N)^2\r\n    BigInteger.prototype.isPrime = function (strict) {\r\n        var isPrime = isBasicPrime(this);\r\n        if (isPrime !== undefined) return isPrime;\r\n        var n = this.abs();\r\n        var bits = n.bitLength();\r\n        if (bits <= 64)\r\n            return millerRabinTest(n, [2, 325, 9375, 28178, 450775, 9780504, 1795265022]);\r\n        var logN = Math.log(2) * bits.toJSNumber();\r\n        var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);\r\n        for (var a = [], i = 0; i < t; i++) {\r\n            a.push(bigInt(i + 2));\r\n        }\r\n        return millerRabinTest(n, a);\r\n    };\r\n    NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;\r\n\r\n    BigInteger.prototype.isProbablePrime = function (iterations) {\r\n        var isPrime = isBasicPrime(this);\r\n        if (isPrime !== undefined) return isPrime;\r\n        var n = this.abs();\r\n        var t = iterations === undefined ? 5 : iterations;\r\n        for (var a = [], i = 0; i < t; i++) {\r\n            a.push(bigInt.randBetween(2, n.minus(2)));\r\n        }\r\n        return millerRabinTest(n, a);\r\n    };\r\n    NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;\r\n\r\n    BigInteger.prototype.modInv = function (n) {\r\n        var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;\r\n        while (!newR.isZero()) {\r\n            q = r.divide(newR);\r\n            lastT = t;\r\n            lastR = r;\r\n            t = newT;\r\n            r = newR;\r\n            newT = lastT.subtract(q.multiply(newT));\r\n            newR = lastR.subtract(q.multiply(newR));\r\n        }\r\n        if (!r.isUnit()) throw new Error(this.toString() + \" and \" + n.toString() + \" are not co-prime\");\r\n        if (t.compare(0) === -1) {\r\n            t = t.add(n);\r\n        }\r\n        if (this.isNegative()) {\r\n            return t.negate();\r\n        }\r\n        return t;\r\n    };\r\n\r\n    NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;\r\n\r\n    BigInteger.prototype.next = function () {\r\n        var value = this.value;\r\n        if (this.sign) {\r\n            return subtractSmall(value, 1, this.sign);\r\n        }\r\n        return new BigInteger(addSmall(value, 1), this.sign);\r\n    };\r\n    SmallInteger.prototype.next = function () {\r\n        var value = this.value;\r\n        if (value + 1 < MAX_INT) return new SmallInteger(value + 1);\r\n        return new BigInteger(MAX_INT_ARR, false);\r\n    };\r\n    NativeBigInt.prototype.next = function () {\r\n        return new NativeBigInt(this.value + BigInt(1));\r\n    }\r\n\r\n    BigInteger.prototype.prev = function () {\r\n        var value = this.value;\r\n        if (this.sign) {\r\n            return new BigInteger(addSmall(value, 1), true);\r\n        }\r\n        return subtractSmall(value, 1, this.sign);\r\n    };\r\n    SmallInteger.prototype.prev = function () {\r\n        var value = this.value;\r\n        if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);\r\n        return new BigInteger(MAX_INT_ARR, true);\r\n    };\r\n    NativeBigInt.prototype.prev = function () {\r\n        return new NativeBigInt(this.value - BigInt(1));\r\n    }\r\n\r\n    var powersOfTwo = [1];\r\n    while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);\r\n    var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];\r\n\r\n    function shift_isSmall(n) {\r\n        return Math.abs(n) <= BASE;\r\n    }\r\n\r\n    BigInteger.prototype.shiftLeft = function (v) {\r\n        var n = parseValue(v).toJSNumber();\r\n        if (!shift_isSmall(n)) {\r\n            throw new Error(String(n) + \" is too large for shifting.\");\r\n        }\r\n        if (n < 0) return this.shiftRight(-n);\r\n        var result = this;\r\n        if (result.isZero()) return result;\r\n        while (n >= powers2Length) {\r\n            result = result.multiply(highestPower2);\r\n            n -= powers2Length - 1;\r\n        }\r\n        return result.multiply(powersOfTwo[n]);\r\n    };\r\n    NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;\r\n\r\n    BigInteger.prototype.shiftRight = function (v) {\r\n        var remQuo;\r\n        var n = parseValue(v).toJSNumber();\r\n        if (!shift_isSmall(n)) {\r\n            throw new Error(String(n) + \" is too large for shifting.\");\r\n        }\r\n        if (n < 0) return this.shiftLeft(-n);\r\n        var result = this;\r\n        while (n >= powers2Length) {\r\n            if (result.isZero() || (result.isNegative() && result.isUnit())) return result;\r\n            remQuo = divModAny(result, highestPower2);\r\n            result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n            n -= powers2Length - 1;\r\n        }\r\n        remQuo = divModAny(result, powersOfTwo[n]);\r\n        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n    };\r\n    NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;\r\n\r\n    function bitwise(x, y, fn) {\r\n        y = parseValue(y);\r\n        var xSign = x.isNegative(), ySign = y.isNegative();\r\n        var xRem = xSign ? x.not() : x,\r\n            yRem = ySign ? y.not() : y;\r\n        var xDigit = 0, yDigit = 0;\r\n        var xDivMod = null, yDivMod = null;\r\n        var result = [];\r\n        while (!xRem.isZero() || !yRem.isZero()) {\r\n            xDivMod = divModAny(xRem, highestPower2);\r\n            xDigit = xDivMod[1].toJSNumber();\r\n            if (xSign) {\r\n                xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers\r\n            }\r\n\r\n            yDivMod = divModAny(yRem, highestPower2);\r\n            yDigit = yDivMod[1].toJSNumber();\r\n            if (ySign) {\r\n                yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers\r\n            }\r\n\r\n            xRem = xDivMod[0];\r\n            yRem = yDivMod[0];\r\n            result.push(fn(xDigit, yDigit));\r\n        }\r\n        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);\r\n        for (var i = result.length - 1; i >= 0; i -= 1) {\r\n            sum = sum.multiply(highestPower2).add(bigInt(result[i]));\r\n        }\r\n        return sum;\r\n    }\r\n\r\n    BigInteger.prototype.not = function () {\r\n        return this.negate().prev();\r\n    };\r\n    NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;\r\n\r\n    BigInteger.prototype.and = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a & b; });\r\n    };\r\n    NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;\r\n\r\n    BigInteger.prototype.or = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a | b; });\r\n    };\r\n    NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;\r\n\r\n    BigInteger.prototype.xor = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a ^ b; });\r\n    };\r\n    NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;\r\n\r\n    var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;\r\n    function roughLOB(n) { // get lowestOneBit (rough)\r\n        // SmallInteger: return Min(lowestOneBit(n), 1 << 30)\r\n        // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]\r\n        var v = n.value,\r\n            x = typeof v === \"number\" ? v | LOBMASK_I :\r\n                typeof v === \"bigint\" ? v | BigInt(LOBMASK_I) :\r\n                    v[0] + v[1] * BASE | LOBMASK_BI;\r\n        return x & -x;\r\n    }\r\n\r\n    function integerLogarithm(value, base) {\r\n        if (base.compareTo(value) <= 0) {\r\n            var tmp = integerLogarithm(value, base.square(base));\r\n            var p = tmp.p;\r\n            var e = tmp.e;\r\n            var t = p.multiply(base);\r\n            return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };\r\n        }\r\n        return { p: bigInt(1), e: 0 };\r\n    }\r\n\r\n    BigInteger.prototype.bitLength = function () {\r\n        var n = this;\r\n        if (n.compareTo(bigInt(0)) < 0) {\r\n            n = n.negate().subtract(bigInt(1));\r\n        }\r\n        if (n.compareTo(bigInt(0)) === 0) {\r\n            return bigInt(0);\r\n        }\r\n        return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));\r\n    }\r\n    NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;\r\n\r\n    function max(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        return a.greater(b) ? a : b;\r\n    }\r\n    function min(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        return a.lesser(b) ? a : b;\r\n    }\r\n    function gcd(a, b) {\r\n        a = parseValue(a).abs();\r\n        b = parseValue(b).abs();\r\n        if (a.equals(b)) return a;\r\n        if (a.isZero()) return b;\r\n        if (b.isZero()) return a;\r\n        var c = Integer[1], d, t;\r\n        while (a.isEven() && b.isEven()) {\r\n            d = min(roughLOB(a), roughLOB(b));\r\n            a = a.divide(d);\r\n            b = b.divide(d);\r\n            c = c.multiply(d);\r\n        }\r\n        while (a.isEven()) {\r\n            a = a.divide(roughLOB(a));\r\n        }\r\n        do {\r\n            while (b.isEven()) {\r\n                b = b.divide(roughLOB(b));\r\n            }\r\n            if (a.greater(b)) {\r\n                t = b; b = a; a = t;\r\n            }\r\n            b = b.subtract(a);\r\n        } while (!b.isZero());\r\n        return c.isUnit() ? a : a.multiply(c);\r\n    }\r\n    function lcm(a, b) {\r\n        a = parseValue(a).abs();\r\n        b = parseValue(b).abs();\r\n        return a.divide(gcd(a, b)).multiply(b);\r\n    }\r\n    function randBetween(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        var low = min(a, b), high = max(a, b);\r\n        var range = high.subtract(low).add(1);\r\n        if (range.isSmall) return low.add(Math.floor(Math.random() * range));\r\n        var digits = toBase(range, BASE).value;\r\n        var result = [], restricted = true;\r\n        for (var i = 0; i < digits.length; i++) {\r\n            var top = restricted ? digits[i] : BASE;\r\n            var digit = truncate(Math.random() * top);\r\n            result.push(digit);\r\n            if (digit < top) restricted = false;\r\n        }\r\n        return low.add(Integer.fromArray(result, BASE, false));\r\n    }\r\n\r\n    var parseBase = function (text, base, alphabet, caseSensitive) {\r\n        alphabet = alphabet || DEFAULT_ALPHABET;\r\n        text = String(text);\r\n        if (!caseSensitive) {\r\n            text = text.toLowerCase();\r\n            alphabet = alphabet.toLowerCase();\r\n        }\r\n        var length = text.length;\r\n        var i;\r\n        var absBase = Math.abs(base);\r\n        var alphabetValues = {};\r\n        for (i = 0; i < alphabet.length; i++) {\r\n            alphabetValues[alphabet[i]] = i;\r\n        }\r\n        for (i = 0; i < length; i++) {\r\n            var c = text[i];\r\n            if (c === \"-\") continue;\r\n            if (c in alphabetValues) {\r\n                if (alphabetValues[c] >= absBase) {\r\n                    if (c === \"1\" && absBase === 1) continue;\r\n                    throw new Error(c + \" is not a valid digit in base \" + base + \".\");\r\n                }\r\n            }\r\n        }\r\n        base = parseValue(base);\r\n        var digits = [];\r\n        var isNegative = text[0] === \"-\";\r\n        for (i = isNegative ? 1 : 0; i < text.length; i++) {\r\n            var c = text[i];\r\n            if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));\r\n            else if (c === \"<\") {\r\n                var start = i;\r\n                do { i++; } while (text[i] !== \">\" && i < text.length);\r\n                digits.push(parseValue(text.slice(start + 1, i)));\r\n            }\r\n            else throw new Error(c + \" is not a valid character\");\r\n        }\r\n        return parseBaseFromArray(digits, base, isNegative);\r\n    };\r\n\r\n    function parseBaseFromArray(digits, base, isNegative) {\r\n        var val = Integer[0], pow = Integer[1], i;\r\n        for (i = digits.length - 1; i >= 0; i--) {\r\n            val = val.add(digits[i].times(pow));\r\n            pow = pow.times(base);\r\n        }\r\n        return isNegative ? val.negate() : val;\r\n    }\r\n\r\n    function stringify(digit, alphabet) {\r\n        alphabet = alphabet || DEFAULT_ALPHABET;\r\n        if (digit < alphabet.length) {\r\n            return alphabet[digit];\r\n        }\r\n        return \"<\" + digit + \">\";\r\n    }\r\n\r\n    function toBase(n, base) {\r\n        base = bigInt(base);\r\n        if (base.isZero()) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n            throw new Error(\"Cannot convert nonzero numbers to base 0.\");\r\n        }\r\n        if (base.equals(-1)) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n            if (n.isNegative())\r\n                return {\r\n                    value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))\r\n                        .map(Array.prototype.valueOf, [1, 0])\r\n                    ),\r\n                    isNegative: false\r\n                };\r\n\r\n            var arr = Array.apply(null, Array(n.toJSNumber() - 1))\r\n                .map(Array.prototype.valueOf, [0, 1]);\r\n            arr.unshift([1]);\r\n            return {\r\n                value: [].concat.apply([], arr),\r\n                isNegative: false\r\n            };\r\n        }\r\n\r\n        var neg = false;\r\n        if (n.isNegative() && base.isPositive()) {\r\n            neg = true;\r\n            n = n.abs();\r\n        }\r\n        if (base.isUnit()) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n\r\n            return {\r\n                value: Array.apply(null, Array(n.toJSNumber()))\r\n                    .map(Number.prototype.valueOf, 1),\r\n                isNegative: neg\r\n            };\r\n        }\r\n        var out = [];\r\n        var left = n, divmod;\r\n        while (left.isNegative() || left.compareAbs(base) >= 0) {\r\n            divmod = left.divmod(base);\r\n            left = divmod.quotient;\r\n            var digit = divmod.remainder;\r\n            if (digit.isNegative()) {\r\n                digit = base.minus(digit).abs();\r\n                left = left.next();\r\n            }\r\n            out.push(digit.toJSNumber());\r\n        }\r\n        out.push(left.toJSNumber());\r\n        return { value: out.reverse(), isNegative: neg };\r\n    }\r\n\r\n    function toBaseString(n, base, alphabet) {\r\n        var arr = toBase(n, base);\r\n        return (arr.isNegative ? \"-\" : \"\") + arr.value.map(function (x) {\r\n            return stringify(x, alphabet);\r\n        }).join('');\r\n    }\r\n\r\n    BigInteger.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    SmallInteger.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    NativeBigInt.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    BigInteger.prototype.toString = function (radix, alphabet) {\r\n        if (radix === undefined) radix = 10;\r\n        if (radix !== 10) return toBaseString(this, radix, alphabet);\r\n        var v = this.value, l = v.length, str = String(v[--l]), zeros = \"0000000\", digit;\r\n        while (--l >= 0) {\r\n            digit = String(v[l]);\r\n            str += zeros.slice(digit.length) + digit;\r\n        }\r\n        var sign = this.sign ? \"-\" : \"\";\r\n        return sign + str;\r\n    };\r\n\r\n    SmallInteger.prototype.toString = function (radix, alphabet) {\r\n        if (radix === undefined) radix = 10;\r\n        if (radix != 10) return toBaseString(this, radix, alphabet);\r\n        return String(this.value);\r\n    };\r\n\r\n    NativeBigInt.prototype.toString = SmallInteger.prototype.toString;\r\n\r\n    NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }\r\n\r\n    BigInteger.prototype.valueOf = function () {\r\n        return parseInt(this.toString(), 10);\r\n    };\r\n    BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;\r\n\r\n    SmallInteger.prototype.valueOf = function () {\r\n        return this.value;\r\n    };\r\n    SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;\r\n    NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {\r\n        return parseInt(this.toString(), 10);\r\n    }\r\n\r\n    function parseStringValue(v) {\r\n        if (isPrecise(+v)) {\r\n            var x = +v;\r\n            if (x === truncate(x))\r\n                return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);\r\n            throw new Error(\"Invalid integer: \" + v);\r\n        }\r\n        var sign = v[0] === \"-\";\r\n        if (sign) v = v.slice(1);\r\n        var split = v.split(/e/i);\r\n        if (split.length > 2) throw new Error(\"Invalid integer: \" + split.join(\"e\"));\r\n        if (split.length === 2) {\r\n            var exp = split[1];\r\n            if (exp[0] === \"+\") exp = exp.slice(1);\r\n            exp = +exp;\r\n            if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error(\"Invalid integer: \" + exp + \" is not a valid exponent.\");\r\n            var text = split[0];\r\n            var decimalPlace = text.indexOf(\".\");\r\n            if (decimalPlace >= 0) {\r\n                exp -= text.length - decimalPlace - 1;\r\n                text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);\r\n            }\r\n            if (exp < 0) throw new Error(\"Cannot include negative exponent part for integers\");\r\n            text += (new Array(exp + 1)).join(\"0\");\r\n            v = text;\r\n        }\r\n        var isValid = /^([0-9][0-9]*)$/.test(v);\r\n        if (!isValid) throw new Error(\"Invalid integer: \" + v);\r\n        if (supportsNativeBigInt) {\r\n            return new NativeBigInt(BigInt(sign ? \"-\" + v : v));\r\n        }\r\n        var r = [], max = v.length, l = LOG_BASE, min = max - l;\r\n        while (max > 0) {\r\n            r.push(+v.slice(min, max));\r\n            min -= l;\r\n            if (min < 0) min = 0;\r\n            max -= l;\r\n        }\r\n        trim(r);\r\n        return new BigInteger(r, sign);\r\n    }\r\n\r\n    function parseNumberValue(v) {\r\n        if (supportsNativeBigInt) {\r\n            return new NativeBigInt(BigInt(v));\r\n        }\r\n        if (isPrecise(v)) {\r\n            if (v !== truncate(v)) throw new Error(v + \" is not an integer.\");\r\n            return new SmallInteger(v);\r\n        }\r\n        return parseStringValue(v.toString());\r\n    }\r\n\r\n    function parseValue(v) {\r\n        if (typeof v === \"number\") {\r\n            return parseNumberValue(v);\r\n        }\r\n        if (typeof v === \"string\") {\r\n            return parseStringValue(v);\r\n        }\r\n        if (typeof v === \"bigint\") {\r\n            return new NativeBigInt(v);\r\n        }\r\n        return v;\r\n    }\r\n    // Pre-define numbers in range [-999,999]\r\n    for (var i = 0; i < 1000; i++) {\r\n        Integer[i] = parseValue(i);\r\n        if (i > 0) Integer[-i] = parseValue(-i);\r\n    }\r\n    // Backwards compatibility\r\n    Integer.one = Integer[1];\r\n    Integer.zero = Integer[0];\r\n    Integer.minusOne = Integer[-1];\r\n    Integer.max = max;\r\n    Integer.min = min;\r\n    Integer.gcd = gcd;\r\n    Integer.lcm = lcm;\r\n    Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };\r\n    Integer.randBetween = randBetween;\r\n\r\n    Integer.fromArray = function (digits, base, isNegative) {\r\n        return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);\r\n    };\r\n\r\n    return Integer;\r\n})();\r\n\r\n// Node.js check\r\nif (typeof module !== \"undefined\" && module.hasOwnProperty(\"exports\")) {\r\n    module.exports = bigInt;\r\n}\r\n\r\n//amd check\r\nif (typeof define === \"function\" && define.amd) {\r\n    define(\"big-integer\", [], function () {\r\n        return bigInt;\r\n    });\r\n}\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class MLOAD {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly location: any;\r\n\r\n    constructor(location: any) {\r\n        this.name = 'MLOAD';\r\n        this.wrapped = true;\r\n        this.location = location;\r\n    }\r\n\r\n    toString() {\r\n        return 'memory[' + stringify(this.location) + ']';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const memoryLocation = state.stack.pop();\r\n    if (BigNumber.isInstance(memoryLocation) && memoryLocation.toJSNumber() in state.memory) {\r\n        state.stack.push(state.memory[memoryLocation.toJSNumber()]);\r\n    } else {\r\n        state.stack.push(new MLOAD(memoryLocation));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class MOD {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'MOD';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' % ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.mod(right));\r\n    } else {\r\n        state.stack.push(new MOD(left, right));\r\n    }\r\n};\r\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class ADD {\r\n    readonly name: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'ADD';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' + ' + stringify(this.right);\r\n    }\r\n\r\n    get type() {\r\n        if (this.left.type === this.right.type) {\r\n            return this.left.type;\r\n        } else if (!this.left.type && this.right.type) {\r\n            return this.right.type;\r\n        } else if (!this.right.type && this.left.type) {\r\n            return this.left.type;\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.add(right));\r\n    } else if (BigNumber.isInstance(left) && left.isZero()) {\r\n        state.stack.push(right);\r\n    } else if (BigNumber.isInstance(right) && right.isZero()) {\r\n        state.stack.push(left);\r\n    } else {\r\n        state.stack.push(new ADD(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class MUL {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'MUL';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' * ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.multiply(right));\r\n    } else if (\r\n        (BigNumber.isInstance(left) && left.isZero()) ||\r\n        (BigNumber.isInstance(right) && right.isZero())\r\n    ) {\r\n        state.stack.push(BigNumber(0));\r\n    } else {\r\n        state.stack.push(new MUL(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class SUB {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'SUB';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' - ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.subtract(right));\r\n    } else {\r\n        state.stack.push(new SUB(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class SHL {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'SHL';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' << ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.shiftLeft(right));\r\n    } else {\r\n        state.stack.push(new SHL(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class SAR {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'SAR';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' >> ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.shiftRight(right));\r\n    } else {\r\n        state.stack.push(new SAR(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class LT {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n    readonly equal: boolean;\r\n\r\n    constructor(left: any, right: any, equal: boolean = false) {\r\n        this.name = 'LT';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n        this.equal = equal;\r\n    }\r\n\r\n    toString() {\r\n        if (this.equal) {\r\n            return stringify(this.left) + ' <= ' + stringify(this.right);\r\n        } else {\r\n            return stringify(this.left) + ' < ' + stringify(this.right);\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(BigNumber(left.lesser(right) === true ? 1 : 0));\r\n    } else {\r\n        state.stack.push(new LT(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class GT {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n    readonly equal: boolean;\r\n\r\n    constructor(left: any, right: any, equal: boolean = false) {\r\n        this.name = 'GT';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n        this.equal = equal;\r\n    }\r\n\r\n    toString() {\r\n        if (this.equal) {\r\n            return stringify(this.left) + ' >= ' + stringify(this.right);\r\n        } else {\r\n            return stringify(this.left) + ' > ' + stringify(this.right);\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(BigNumber(left.greater(right) === true ? 1 : 0));\r\n    } else {\r\n        state.stack.push(new GT(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport * as functionHashes from '../../data/functionHashes.json';\r\nimport stringify from '../utils/stringify';\r\n\r\nconst updateCallDataLoad = (item: any, types: any) => {\r\n    for (const i in item) {\r\n        if (item.hasOwnProperty(i)) {\r\n            if (\r\n                typeof item[i] === 'object' &&\r\n                item[i].name === 'CALLDATALOAD' &&\r\n                BigNumber.isInstance(item[i].location)\r\n            ) {\r\n                const argNumber = item[i].location\r\n                    .subtract(4)\r\n                    .divide(32)\r\n                    .toString();\r\n                item[i].type = types[argNumber];\r\n            }\r\n            if (typeof item[i] === 'object') {\r\n                updateCallDataLoad(item[i], types);\r\n            }\r\n        }\r\n    }\r\n};\r\n\r\nconst findReturns = (item: any) => {\r\n    const returns = [];\r\n    for (const i in item) {\r\n        if (item.hasOwnProperty(i)) {\r\n            if (\r\n                typeof item[i] === 'object' &&\r\n                item[i].name === 'RETURN' &&\r\n                item[i].items &&\r\n                item[i].items.length > 0\r\n            ) {\r\n                returns.push(item[i].items);\r\n            }\r\n            if (typeof item[i] === 'object') {\r\n                const deepReturns: any = findReturns(item[i]);\r\n                if (deepReturns.length > 0) {\r\n                    returns.push(...deepReturns);\r\n                }\r\n            }\r\n        }\r\n    }\r\n    return returns;\r\n};\r\n\r\nexport class TopLevelFunction {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly hash: any;\r\n    readonly gasUsed: number;\r\n    readonly payable: boolean;\r\n    readonly visibility: string;\r\n    readonly constant: boolean;\r\n    readonly items: any;\r\n    readonly returns: any;\r\n\r\n    constructor(items: any, hash: any, gasUsed: number) {\r\n        this.name = 'Function';\r\n        this.hash = hash;\r\n        this.gasUsed = gasUsed;\r\n        this.items = items;\r\n        this.payable = true;\r\n        this.visibility = 'public';\r\n        this.constant = false;\r\n        this.returns = [];\r\n        if (\r\n            this.items.length > 0 &&\r\n            this.items[0] instanceof REQUIRE &&\r\n            this.items[0].condition.name === 'ISZERO' &&\r\n            this.items[0].condition.item.name === 'CALLVALUE'\r\n        ) {\r\n            this.payable = false;\r\n            this.items.shift();\r\n        }\r\n        if (this.items.length === 1 && this.items[0].name === 'RETURN') {\r\n            this.constant = true;\r\n        }\r\n        if (this.hash in functionHashes) {\r\n            const functionName = (functionHashes as any)[this.hash].split('(')[0];\r\n            const argumentTypes = (functionHashes as any)[this.hash]\r\n                .replace(functionName, '')\r\n                .substr(1)\r\n                .slice(0, -1)\r\n                .split(',');\r\n            if (\r\n                argumentTypes.length > 1 ||\r\n                (argumentTypes.length === 1 && argumentTypes[0] !== '')\r\n            ) {\r\n                this.items.forEach((item: any) => updateCallDataLoad(item, argumentTypes));\r\n            }\r\n        }\r\n        const returns: any = [];\r\n        this.items.forEach((item: any) => {\r\n            const deepReturns = findReturns(item);\r\n            if (deepReturns.length > 0) {\r\n                returns.push(...deepReturns);\r\n            }\r\n        });\r\n        if (\r\n            returns.length > 0 &&\r\n            returns.every(\r\n                (returnItem: any) =>\r\n                    returnItem.length === returns[0].length &&\r\n                    returnItem.map((item: any) => item.type).join('') ===\r\n                        returns[0].map((item: any) => item.type).join('')\r\n            )\r\n        ) {\r\n            returns[0].forEach((item: any) => {\r\n                if (BigNumber.isInstance(item)) {\r\n                    this.returns.push('uint256');\r\n                } else if (item.type) {\r\n                    this.returns.push(item.type);\r\n                } else {\r\n                    this.returns.push('unknown');\r\n                }\r\n            });\r\n        } else if (returns.length > 0) {\r\n            this.returns.push('<unknown>');\r\n        }\r\n    }\r\n}\r\n\r\nexport class Variable {\r\n    readonly name: string;\r\n    readonly label: string | false;\r\n    readonly types: any;\r\n\r\n    constructor(label: string | false, types: any) {\r\n        this.name = 'Variable';\r\n        this.label = label;\r\n        this.types = types;\r\n    }\r\n}\r\n\r\nexport class REQUIRE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly condition: any;\r\n\r\n    constructor(condition: any) {\r\n        this.name = 'REQUIRE';\r\n        this.wrapped = true;\r\n        this.condition = condition;\r\n    }\r\n\r\n    toString() {\r\n        return 'require(' + stringify(this.condition) + ');';\r\n    }\r\n}\r\n\r\nexport class JUMPI {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly condition: any;\r\n    readonly location: any;\r\n    readonly valid: boolean;\r\n    readonly true?: any;\r\n    readonly false?: any;\r\n    readonly payable?: boolean;\r\n\r\n    constructor(condition: any, location: any, ifTrue?: any, ifFalse?: any, skipped?: boolean) {\r\n        this.name = 'JUMPI';\r\n        this.wrapped = true;\r\n        this.condition = condition;\r\n        this.location = location;\r\n        if (skipped) {\r\n            this.valid = true;\r\n        } else if (ifTrue && ifFalse) {\r\n            this.valid = true;\r\n            this.true = ifTrue;\r\n            this.false = ifFalse;\r\n            if (\r\n                this.true.length >= 1 &&\r\n                this.true[0] instanceof REQUIRE &&\r\n                this.true[0].condition.name === 'ISZERO' &&\r\n                this.true[0].condition.item.name === 'CALLVALUE'\r\n            ) {\r\n                this.payable = false;\r\n                this.true.shift();\r\n            } else {\r\n                this.payable = true;\r\n            }\r\n        } else {\r\n            this.valid = false;\r\n        }\r\n    }\r\n\r\n    toString() {\r\n        if (this.valid && this.true && this.false) {\r\n            return stringify(this.condition);\r\n        } else if (this.valid) {\r\n            return 'if' + stringify(this.condition) + ' goto(' + stringify(this.location) + ');';\r\n        } else {\r\n            return \"revert(\\\"Bad jump destination\\\");\";\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const jumpLocation = state.stack.pop();\r\n    const jumpCondition = state.stack.pop();\r\n    const opcodes = state.getOpcodes();\r\n    if (!BigNumber.isInstance(jumpLocation)) {\r\n        state.halted = true;\r\n        state.instructions.push(new JUMPI(jumpCondition, jumpLocation));\r\n    } else {\r\n        const jumpLocationData = opcodes.find((o: any) => o.pc === jumpLocation.toJSNumber());\r\n        if (!jumpLocationData || jumpLocationData.name !== 'JUMPDEST') {\r\n            state.halted = true;\r\n            state.instructions.push(new JUMPI(jumpCondition, jumpLocation));\r\n        } else if (BigNumber.isInstance(jumpCondition)) {\r\n            const jumpIndex = opcodes.indexOf(jumpLocationData);\r\n            if (\r\n                jumpIndex >= 0 &&\r\n                !jumpCondition.equals(0) &&\r\n                !(opcode.pc + ':' + jumpLocation.toJSNumber() in state.jumps)\r\n            ) {\r\n                state.jumps[opcode.pc + ':' + jumpLocation.toJSNumber()] = true;\r\n                state.pc = jumpIndex;\r\n            }\r\n        } else if (\r\n            !(opcode.pc + ':' + jumpLocation.toJSNumber() in state.jumps) &&\r\n            jumpCondition.name === 'SIG'\r\n        ) {\r\n            const jumpIndex = opcodes.indexOf(jumpLocationData);\r\n            if (jumpIndex >= 0) {\r\n                const functionClone: any = state.clone();\r\n                functionClone.pc = jumpIndex;\r\n                const functionCloneTree = functionClone.parse();\r\n                state.functions[jumpCondition.hash] = new TopLevelFunction(\r\n                    functionCloneTree,\r\n                    jumpCondition.hash,\r\n                    functionClone.gasUsed\r\n                );\r\n                if (\r\n                    jumpCondition.hash in functionHashes &&\r\n                    functionCloneTree.length === 1 &&\r\n                    functionCloneTree[0].name === 'RETURN' &&\r\n                    functionCloneTree[0].items.every((item: any) => item.name === 'MappingLoad')\r\n                ) {\r\n                    functionCloneTree[0].items.forEach((item: any) => {\r\n                        const fullFunction = (functionHashes as any)[jumpCondition.hash];\r\n                        state.mappings[item.location].name = fullFunction.split('(')[0];\r\n                        if (\r\n                            item.structlocation &&\r\n                            !state.mappings[item.location].structs.includes(item.structlocation)\r\n                        ) {\r\n                            state.mappings[item.location].structs.push(item.structlocation);\r\n                        }\r\n                    });\r\n                    delete state.functions[jumpCondition.hash];\r\n                } else if (\r\n                    jumpCondition.hash in functionHashes &&\r\n                    state.functions[jumpCondition.hash].items.length === 1 &&\r\n                    state.functions[jumpCondition.hash].items[0].name === 'RETURN' &&\r\n                    state.functions[jumpCondition.hash].items[0].items.length === 1 &&\r\n                    state.functions[jumpCondition.hash].items[0].items[0].name === 'SLOAD' &&\r\n                    BigNumber.isInstance(\r\n                        state.functions[jumpCondition.hash].items[0].items[0].location\r\n                    )\r\n                ) {\r\n                    if (\r\n                        !(\r\n                            state.functions[jumpCondition.hash].items[0].items[0].location in\r\n                            state.variables\r\n                        )\r\n                    ) {\r\n                        const fullFunction = (functionHashes as any)[jumpCondition.hash];\r\n                        state.variables[\r\n                            state.functions[jumpCondition.hash].items[0].items[0].location\r\n                        ] = new Variable(fullFunction.split('(')[0], []);\r\n                        delete state.functions[jumpCondition.hash];\r\n                    } else {\r\n                        const fullFunction = (functionHashes as any)[jumpCondition.hash];\r\n                        state.variables[\r\n                            state.functions[jumpCondition.hash].items[0].items[0].location\r\n                        ].label = fullFunction.split('(')[0];\r\n                        delete state.functions[jumpCondition.hash];\r\n                    }\r\n                }\r\n            }\r\n        } else if (\r\n            !(opcode.pc + ':' + jumpLocation.toJSNumber() in state.jumps) &&\r\n            ((jumpCondition.name === 'LT' &&\r\n                jumpCondition.left.name === 'CALLDATASIZE' &&\r\n                BigNumber.isInstance(jumpCondition.right) &&\r\n                jumpCondition.right.equals(4)) ||\r\n                (jumpCondition.name === 'ISZERO' && jumpCondition.item.name === 'CALLDATASIZE'))\r\n        ) {\r\n            const jumpIndex = opcodes.indexOf(jumpLocationData);\r\n            if (jumpIndex >= 0) {\r\n                state.halted = true;\r\n                const trueClone: any = state.clone();\r\n                trueClone.pc = jumpIndex;\r\n                const trueCloneTree = trueClone.parse();\r\n                const falseClone = state.clone();\r\n                falseClone.pc = state.pc + 1;\r\n                const falseCloneTree: any = falseClone.parse();\r\n                if (\r\n                    trueCloneTree.length > 0 &&\r\n                    trueCloneTree.length === falseCloneTree.length &&\r\n                    trueCloneTree[0].name !== 'REVERT' &&\r\n                    trueCloneTree[0].name !== 'INVALID' &&\r\n                    trueCloneTree.map((item: any) => stringify(item)).join('') ===\r\n                        falseCloneTree.map((item: any) => stringify(item)).join('')\r\n                ) {\r\n                    state.functions[''] = new TopLevelFunction(\r\n                        trueCloneTree,\r\n                        '',\r\n                        trueCloneTree.gasUsed\r\n                    );\r\n                } else if (\r\n                    trueCloneTree.length > 0 &&\r\n                    trueCloneTree[0].name !== 'REVERT' &&\r\n                    trueCloneTree[0].name !== 'INVALID'\r\n                ) {\r\n                    state.instructions.push(\r\n                        new JUMPI(jumpCondition, jumpLocation, trueCloneTree, falseCloneTree)\r\n                    );\r\n                }\r\n            } else {\r\n                state.instructions.push(new JUMPI(jumpCondition, jumpLocation));\r\n            }\r\n        } else if (!(opcode.pc + ':' + jumpLocation.toJSNumber() in state.jumps)) {\r\n            const jumpIndex = opcodes.indexOf(jumpLocationData);\r\n            state.jumps[opcode.pc + ':' + jumpLocation.toJSNumber()] = true;\r\n            if (jumpIndex >= 0) {\r\n                state.halted = true;\r\n                const trueClone: any = state.clone();\r\n                trueClone.pc = jumpIndex;\r\n                const trueCloneTree = trueClone.parse();\r\n                const falseClone = state.clone();\r\n                falseClone.pc = state.pc + 1;\r\n                const falseCloneTree: any = falseClone.parse();\r\n                if (\r\n                    (falseCloneTree.length === 1 &&\r\n                        'name' in falseCloneTree[0] &&\r\n                        (falseCloneTree[0].name === 'REVERT' &&\r\n                            falseCloneTree[0].items &&\r\n                            falseCloneTree[0].items.length === 0)) ||\r\n                    falseCloneTree[0].name === 'INVALID'\r\n                ) {\r\n                    state.instructions.push(new REQUIRE(jumpCondition));\r\n                    state.instructions.push(...trueCloneTree);\r\n                } else {\r\n                    state.instructions.push(\r\n                        new JUMPI(jumpCondition, jumpLocation, trueCloneTree, falseCloneTree)\r\n                    );\r\n                }\r\n            } else {\r\n                state.instructions.push(new JUMPI(jumpCondition, jumpLocation));\r\n            }\r\n        } else {\r\n            state.instructions.push(new JUMPI(jumpCondition, jumpLocation, null, null, true));\r\n        }\r\n    }\r\n};\r\n","export const stringifyInstructions = (instructionTree: any, indentation = 0): string => {\r\n    let instructionLines = '';\r\n    instructionTree.forEach((instruction: any) => {\r\n        if (instruction.name === 'JUMPI' && instruction.false) {\r\n            const condition = instruction.toString();\r\n            const falseInstructions = instruction.false.filter((i: any) => i.debugLevel > 0);\r\n            if (falseInstructions.length === 1 && falseInstructions[0].name === 'JUMPI') {\r\n                instructionLines += ' '.repeat(indentation) + 'if' + condition + ' {\\n';\r\n                instructionLines += stringifyInstructions(instruction.true, indentation + 4);\r\n                instructionLines += ' '.repeat(indentation) + '} else ';\r\n                const elseOrElseIf = stringifyInstructions(instruction.false, indentation);\r\n                if (elseOrElseIf.trim().startsWith('if')) {\r\n                    instructionLines += elseOrElseIf.trim() + '\\n';\r\n                } else {\r\n                    instructionLines +=\r\n                        '{\\n' +\r\n                        elseOrElseIf\r\n                            .split('\\n')\r\n                            .filter(l => l)\r\n                            .map(l => ' '.repeat(4) + l)\r\n                            .join('\\n');\r\n                    instructionLines += '\\n' + ' '.repeat(indentation) + '}\\n';\r\n                }\r\n            } else {\r\n                instructionLines += ' '.repeat(indentation) + 'if' + condition + ' {\\n';\r\n                instructionLines += stringifyInstructions(instruction.true, indentation + 4);\r\n                instructionLines += ' '.repeat(indentation) + '} else {\\n';\r\n                instructionLines += stringifyInstructions(instruction.false, indentation + 4);\r\n                instructionLines += ' '.repeat(indentation) + '}\\n';\r\n            }\r\n        } else {\r\n            instructionLines += ' '.repeat(indentation) + instruction.toString() + '\\n';\r\n        }\r\n    });\r\n    return instructionLines;\r\n};\r\n\r\nexport default stringifyInstructions;\r\n","import * as _functions from '../data/functions.json';\r\nimport * as _events from '../data/events.json';\r\nimport * as _functionHashes from '../data/functionHashes.json';\r\nimport * as _eventHashes from '../data/eventHashes.json';\r\nimport Transaction from './classes/tx.class';\r\nimport EVM from './classes/evm.class';\r\n\r\nexport const functions: any = _functions as any;\r\nexport const events: any = _events as any;\r\nexport const functionHashes: any = _functionHashes as any;\r\nexport const eventHashes: any = _eventHashes as any;\r\n\r\nexport { EVM, Transaction };\r\n","import * as BigNumber from '../../node_modules/big-integer';\r\nimport * as functionHashes from '../../data/functionHashes.json';\r\n\r\nconst parseSingle = (data: any, type: any) => {\r\n    if (type === 'string') {\r\n        return '\"' + Buffer.from(data, 'hex').toString('utf8') + '\"';\r\n    } else if (type === 'address') {\r\n        return '0x' + data.substring(24);\r\n    } else if (type === 'uint256' || type === 'uint8') {\r\n        return BigNumber(data, 16).toString();\r\n    } else if (type === 'bool') {\r\n        return (!BigNumber(data, 16).isZero()).toString();\r\n    } else {\r\n        return data;\r\n    }\r\n};\r\n\r\nexport default class Transaction {\r\n    blockHash?: string;\r\n    blockNumber?: number;\r\n    from?: string;\r\n    gas?: number;\r\n    gasPrice?: number;\r\n    input?: string;\r\n    to?: string;\r\n    value?: number;\r\n\r\n    constructor(transactionObject?: any) {\r\n        if (transactionObject) {\r\n            if ('blockHash' in transactionObject) {\r\n                this.blockHash = transactionObject.blockHash;\r\n            }\r\n            if ('blockNumber' in transactionObject) {\r\n                this.blockNumber = transactionObject.blockNumber;\r\n            }\r\n            if ('from' in transactionObject) {\r\n                this.from = transactionObject.from;\r\n            }\r\n            if ('gas' in transactionObject) {\r\n                this.gas = transactionObject.gas;\r\n            }\r\n            if ('gasPrice' in transactionObject) {\r\n                this.gasPrice = transactionObject.gasPrice;\r\n            }\r\n            if ('input' in transactionObject) {\r\n                this.input = transactionObject.input.replace('0x', '');\r\n            }\r\n            if ('to' in transactionObject) {\r\n                this.to = transactionObject.to;\r\n            }\r\n            if ('value' in transactionObject) {\r\n                this.value = transactionObject.value;\r\n            }\r\n        }\r\n    }\r\n\r\n    setInput(input: string): void {\r\n        this.input = input.replace('0x', '');\r\n    }\r\n\r\n    getFunctionHash(): string | false {\r\n        if (this.input && this.input.length >= 8) {\r\n            return this.input.substr(0, 8);\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    getFunction(): string | false {\r\n        const functionHash = this.getFunctionHash();\r\n        if (functionHash && functionHash in functionHashes) {\r\n            return (functionHashes as any)[functionHash];\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    getFunctionName(): string | false {\r\n        const rawFunction = this.getFunction();\r\n        if (rawFunction) {\r\n            return rawFunction.split('(')[0];\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    getRawArguments(): string[] {\r\n        if (this.input && this.input.length >= 70) {\r\n            return this.input.substr(8).match(/.{1,64}/g)!;\r\n        } else {\r\n            return [];\r\n        }\r\n    }\r\n\r\n    getArguments(descriptive: boolean = true): string[] {\r\n        const functionName = this.getFunction();\r\n        const functionArguments = this.getRawArguments();\r\n        if (functionName && this.input) {\r\n            const rawFunctionArguments = functionName\r\n                .split('(')[1]\r\n                .slice(0, -1)\r\n                .split(',');\r\n            if (\r\n                rawFunctionArguments.length === 1 &&\r\n                rawFunctionArguments[0] === '' &&\r\n                functionArguments.length === 0\r\n            ) {\r\n                return [];\r\n            } else {\r\n                const result: string[] = [];\r\n                for (let i = 0; i < rawFunctionArguments.length; i++) {\r\n                    const functionArgumentType = rawFunctionArguments[i] || 'unknown';\r\n                    const functionArgument = functionArguments[i];\r\n                    if (functionArgumentType === 'string') {\r\n                        const location = BigNumber(functionArgument, 16)\r\n                            .divide(32)\r\n                            .toJSNumber();\r\n                        const length = BigNumber(functionArguments[location], 16)\r\n                            .multiply(2)\r\n                            .toJSNumber();\r\n                        const data = this.input.substring(8).substr((location + 1) * 64, length);\r\n                        result.push(parseSingle(data, functionArgumentType));\r\n                    } else {\r\n                        result.push(parseSingle(functionArgument, functionArgumentType));\r\n                    }\r\n                }\r\n                return result;\r\n            }\r\n        } else {\r\n            return functionArguments;\r\n        }\r\n    }\r\n\r\n    isContractCreation(): boolean {\r\n        return this.to === null;\r\n    }\r\n}\r\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  for (var i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","const findOpcode = require('../../node_modules/ethereumjs-vm/dist/opcodes.js');\r\nimport * as functionHashes from '../../data/functionHashes.json';\r\nimport * as eventHashes from '../../data/eventHashes.json';\r\nimport opcodeFunctions from '../utils/opcodes';\r\nimport stringifyEvents from '../utils/stringifyEvents';\r\nimport stringifyStructs from '../utils/stringifyStructs';\r\nimport stringifyMappings from '../utils/stringifyMappings';\r\nimport stringifyVariables from '../utils/stringifyVariables';\r\nimport stringifyFunctions from '../utils/stringifyFunctions';\r\nimport stringifyInstructions from '../utils/stringifyInstructions';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport Stack from './stack.class';\r\nimport Memory from '../interfaces/memory.interface';\r\nimport Storage from '../interfaces/storage.interface';\r\nimport Jumps from '../interfaces/jumps.interface';\r\n\r\nclass EVM {\r\n    pc: number;\r\n    stack: Stack;\r\n    memory: Memory;\r\n    opcodes: Opcode[];\r\n    instructions: any;\r\n    storage: Storage;\r\n    jumps: Jumps;\r\n    code: Buffer;\r\n    mappings: any;\r\n    layer: number;\r\n    halted: boolean;\r\n    functions: any;\r\n    variables: any;\r\n    events: any;\r\n    gasUsed: number;\r\n\r\n    constructor(code: string | Buffer) {\r\n        this.pc = 0;\r\n        this.opcodes = [];\r\n        this.instructions = [];\r\n        this.stack = new Stack();\r\n        this.memory = {};\r\n        this.storage = {};\r\n        this.jumps = {};\r\n        this.mappings = {};\r\n        this.layer = 0;\r\n        this.halted = false;\r\n        this.functions = {};\r\n        this.variables = {};\r\n        this.events = {};\r\n        this.gasUsed = 0;\r\n        if (code instanceof Buffer) {\r\n            this.code = code;\r\n        } else {\r\n            this.code = Buffer.from(code.replace('0x', ''), 'hex');\r\n        }\r\n    }\r\n\r\n    clone(): EVM {\r\n        const clone = new EVM(this.code);\r\n        clone.pc = this.pc;\r\n        clone.opcodes = this.opcodes;\r\n        clone.stack = this.stack.clone();\r\n        clone.memory = { ...this.memory };\r\n        clone.storage = this.storage;\r\n        clone.jumps = { ...this.jumps };\r\n        clone.mappings = this.mappings;\r\n        clone.layer = this.layer + 1;\r\n        clone.functions = this.functions;\r\n        clone.variables = this.variables;\r\n        clone.events = this.events;\r\n        clone.gasUsed = this.gasUsed;\r\n        return clone;\r\n    }\r\n\r\n    getBytecode(): string {\r\n        return '0x' + this.code.toString('hex');\r\n    }\r\n\r\n    getOpcodes(): Opcode[] {\r\n        if (this.opcodes.length === 0) {\r\n            for (let index = 0; index < this.code.length; index++) {\r\n                const currentOp = findOpcode(this.code[index], true);\r\n                currentOp.pc = index;\r\n                this.opcodes.push(currentOp);\r\n                if (currentOp.name.startsWith('PUSH')) {\r\n                    const pushDataLength = this.code[index] - 0x5f;\r\n                    const pushData = this.code.slice(index + 1, index + pushDataLength + 1);\r\n                    currentOp.pushData = pushData;\r\n                    index += pushDataLength;\r\n                }\r\n            }\r\n        }\r\n        return this.opcodes;\r\n    }\r\n\r\n    getFunctions(): string[] {\r\n        return [\r\n            ...new Set(\r\n                this.getOpcodes()\r\n                    .filter(opcode => opcode.name === 'PUSH4')\r\n                    .map(opcode => (opcode.pushData ? opcode.pushData.toString('hex') : ''))\r\n                    .filter(hash => hash in functionHashes)\r\n                    .map(hash => (functionHashes as any)[hash])\r\n            )\r\n        ];\r\n    }\r\n\r\n    getEvents(): string[] {\r\n        return [\r\n            ...new Set(\r\n                this.getOpcodes()\r\n                    .filter(opcode => opcode.name === 'PUSH32')\r\n                    .map(opcode => (opcode.pushData ? opcode.pushData.toString('hex') : ''))\r\n                    .filter(hash => hash in eventHashes)\r\n                    .map(hash => (eventHashes as any)[hash])\r\n            )\r\n        ];\r\n    }\r\n\r\n    getJumpDestinations(): number[] {\r\n        return this.getOpcodes()\r\n            .filter(opcode => opcode.name === 'JUMPDEST')\r\n            .map(opcode => opcode.pc);\r\n    }\r\n\r\n    getTotalGas(): number {\r\n        return this.getOpcodes()\r\n            .map(opcode => opcode.fee)\r\n            .reduce((a: number, b: number) => a + b);\r\n    }\r\n\r\n    getSwarmHash(): string | boolean {\r\n        const regex = /a165627a7a72305820([a-f0-9]{64})0029$/;\r\n        const bytecode = this.getBytecode();\r\n        const match = bytecode.match(regex);\r\n        if (match && match[1]) {\r\n            return 'bzzr://' + match[1];\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    reset(): void {\r\n        this.pc = 0;\r\n        this.instructions = [];\r\n        this.stack.reset();\r\n        this.memory = {};\r\n        this.storage = {};\r\n        this.jumps = {};\r\n        this.mappings = {};\r\n        this.functions = {};\r\n        this.variables = {};\r\n        this.events = {};\r\n        this.gasUsed = 0;\r\n    }\r\n\r\n    parse(): any[] {\r\n        if (this.instructions.length === 0) {\r\n            const opcodes = this.getOpcodes();\r\n            for (this.pc; this.pc < opcodes.length && !this.halted; this.pc++) {\r\n                const opcode = opcodes[this.pc];\r\n                this.gasUsed += opcode.fee;\r\n                if (!(opcode.name in opcodeFunctions)) {\r\n                    throw new Error('Unknown OPCODE: ' + opcode.name);\r\n                } else {\r\n                    (opcodeFunctions as any)[opcode.name](opcode, this);\r\n                }\r\n            }\r\n        }\r\n        return this.instructions;\r\n    }\r\n\r\n    decompile(): string {\r\n        const instructionTree = this.parse();\r\n        const events = stringifyEvents(this.events, this.getEvents());\r\n        const structs = stringifyStructs(this.mappings);\r\n        const mappings = stringifyMappings(this.mappings);\r\n        const variables = stringifyVariables(this.variables);\r\n        const functions = Object.keys(this.functions)\r\n            .map((functionName: string) =>\r\n                stringifyFunctions(functionName, this.functions[functionName])\r\n            )\r\n            .join('');\r\n        const code = stringifyInstructions(instructionTree);\r\n        return events + structs + mappings + variables + functions + code;\r\n    }\r\n}\r\n\r\nexport default EVM;\r\n","'use strict';\n\nvar codes = {\n  // 0x0 range - arithmetic ops\n  // name, baseCost, off stack, on stack, dynamic, async\n  0x00: ['STOP', 0, 0, 0, false],\n  0x01: ['ADD', 3, 2, 1, false],\n  0x02: ['MUL', 5, 2, 1, false],\n  0x03: ['SUB', 3, 2, 1, false],\n  0x04: ['DIV', 5, 2, 1, false],\n  0x05: ['SDIV', 5, 2, 1, false],\n  0x06: ['MOD', 5, 2, 1, false],\n  0x07: ['SMOD', 5, 2, 1, false],\n  0x08: ['ADDMOD', 8, 3, 1, false],\n  0x09: ['MULMOD', 8, 3, 1, false],\n  0x0a: ['EXP', 10, 2, 1, false],\n  0x0b: ['SIGNEXTEND', 5, 2, 1, false],\n\n  // 0x10 range - bit ops\n  0x10: ['LT', 3, 2, 1, false],\n  0x11: ['GT', 3, 2, 1, false],\n  0x12: ['SLT', 3, 2, 1, false],\n  0x13: ['SGT', 3, 2, 1, false],\n  0x14: ['EQ', 3, 2, 1, false],\n  0x15: ['ISZERO', 3, 1, 1, false],\n  0x16: ['AND', 3, 2, 1, false],\n  0x17: ['OR', 3, 2, 1, false],\n  0x18: ['XOR', 3, 2, 1, false],\n  0x19: ['NOT', 3, 1, 1, false],\n  0x1a: ['BYTE', 3, 2, 1, false],\n  0x1b: ['SHL', 3, 2, 1, false],\n  0x1c: ['SHR', 3, 2, 1, false],\n  0x1d: ['SAR', 3, 2, 1, false],\n\n  // 0x20 range - crypto\n  0x20: ['SHA3', 30, 2, 1, false],\n\n  // 0x30 range - closure state\n  0x30: ['ADDRESS', 2, 0, 1, true],\n  0x31: ['BALANCE', 400, 1, 1, true, true],\n  0x32: ['ORIGIN', 2, 0, 1, true],\n  0x33: ['CALLER', 2, 0, 1, true],\n  0x34: ['CALLVALUE', 2, 0, 1, true],\n  0x35: ['CALLDATALOAD', 3, 1, 1, true],\n  0x36: ['CALLDATASIZE', 2, 0, 1, true],\n  0x37: ['CALLDATACOPY', 3, 3, 0, true],\n  0x38: ['CODESIZE', 2, 0, 1, false],\n  0x39: ['CODECOPY', 3, 3, 0, false],\n  0x3a: ['GASPRICE', 2, 0, 1, false],\n  0x3b: ['EXTCODESIZE', 700, 1, 1, true, true],\n  0x3c: ['EXTCODECOPY', 700, 4, 0, true, true],\n  0x3d: ['RETURNDATASIZE', 2, 0, 1, true],\n  0x3e: ['RETURNDATACOPY', 3, 3, 0, true],\n  0x3f: ['EXTCODEHASH', 400, 1, 1, true, true],\n\n  // '0x40' range - block operations\n  0x40: ['BLOCKHASH', 20, 1, 1, true, true],\n  0x41: ['COINBASE', 2, 0, 1, true],\n  0x42: ['TIMESTAMP', 2, 0, 1, true],\n  0x43: ['NUMBER', 2, 0, 1, true],\n  0x44: ['DIFFICULTY', 2, 0, 1, true],\n  0x45: ['GASLIMIT', 2, 0, 1, true],\n\n  // 0x50 range - 'storage' and execution\n  0x50: ['POP', 2, 1, 0, false],\n  0x51: ['MLOAD', 3, 1, 1, false],\n  0x52: ['MSTORE', 3, 2, 0, false],\n  0x53: ['MSTORE8', 3, 2, 0, false],\n  0x54: ['SLOAD', 200, 1, 1, true, true],\n  0x55: ['SSTORE', 0, 2, 0, true, true],\n  0x56: ['JUMP', 8, 1, 0, false],\n  0x57: ['JUMPI', 10, 2, 0, false],\n  0x58: ['PC', 2, 0, 1, false],\n  0x59: ['MSIZE', 2, 0, 1, false],\n  0x5a: ['GAS', 2, 0, 1, false],\n  0x5b: ['JUMPDEST', 1, 0, 0, false],\n\n  // 0x60, range\n  0x60: ['PUSH', 3, 0, 1, false],\n  0x61: ['PUSH', 3, 0, 1, false],\n  0x62: ['PUSH', 3, 0, 1, false],\n  0x63: ['PUSH', 3, 0, 1, false],\n  0x64: ['PUSH', 3, 0, 1, false],\n  0x65: ['PUSH', 3, 0, 1, false],\n  0x66: ['PUSH', 3, 0, 1, false],\n  0x67: ['PUSH', 3, 0, 1, false],\n  0x68: ['PUSH', 3, 0, 1, false],\n  0x69: ['PUSH', 3, 0, 1, false],\n  0x6a: ['PUSH', 3, 0, 1, false],\n  0x6b: ['PUSH', 3, 0, 1, false],\n  0x6c: ['PUSH', 3, 0, 1, false],\n  0x6d: ['PUSH', 3, 0, 1, false],\n  0x6e: ['PUSH', 3, 0, 1, false],\n  0x6f: ['PUSH', 3, 0, 1, false],\n  0x70: ['PUSH', 3, 0, 1, false],\n  0x71: ['PUSH', 3, 0, 1, false],\n  0x72: ['PUSH', 3, 0, 1, false],\n  0x73: ['PUSH', 3, 0, 1, false],\n  0x74: ['PUSH', 3, 0, 1, false],\n  0x75: ['PUSH', 3, 0, 1, false],\n  0x76: ['PUSH', 3, 0, 1, false],\n  0x77: ['PUSH', 3, 0, 1, false],\n  0x78: ['PUSH', 3, 0, 1, false],\n  0x79: ['PUSH', 3, 0, 1, false],\n  0x7a: ['PUSH', 3, 0, 1, false],\n  0x7b: ['PUSH', 3, 0, 1, false],\n  0x7c: ['PUSH', 3, 0, 1, false],\n  0x7d: ['PUSH', 3, 0, 1, false],\n  0x7e: ['PUSH', 3, 0, 1, false],\n  0x7f: ['PUSH', 3, 0, 1, false],\n\n  0x80: ['DUP', 3, 0, 1, false],\n  0x81: ['DUP', 3, 0, 1, false],\n  0x82: ['DUP', 3, 0, 1, false],\n  0x83: ['DUP', 3, 0, 1, false],\n  0x84: ['DUP', 3, 0, 1, false],\n  0x85: ['DUP', 3, 0, 1, false],\n  0x86: ['DUP', 3, 0, 1, false],\n  0x87: ['DUP', 3, 0, 1, false],\n  0x88: ['DUP', 3, 0, 1, false],\n  0x89: ['DUP', 3, 0, 1, false],\n  0x8a: ['DUP', 3, 0, 1, false],\n  0x8b: ['DUP', 3, 0, 1, false],\n  0x8c: ['DUP', 3, 0, 1, false],\n  0x8d: ['DUP', 3, 0, 1, false],\n  0x8e: ['DUP', 3, 0, 1, false],\n  0x8f: ['DUP', 3, 0, 1, false],\n\n  0x90: ['SWAP', 3, 0, 0, false],\n  0x91: ['SWAP', 3, 0, 0, false],\n  0x92: ['SWAP', 3, 0, 0, false],\n  0x93: ['SWAP', 3, 0, 0, false],\n  0x94: ['SWAP', 3, 0, 0, false],\n  0x95: ['SWAP', 3, 0, 0, false],\n  0x96: ['SWAP', 3, 0, 0, false],\n  0x97: ['SWAP', 3, 0, 0, false],\n  0x98: ['SWAP', 3, 0, 0, false],\n  0x99: ['SWAP', 3, 0, 0, false],\n  0x9a: ['SWAP', 3, 0, 0, false],\n  0x9b: ['SWAP', 3, 0, 0, false],\n  0x9c: ['SWAP', 3, 0, 0, false],\n  0x9d: ['SWAP', 3, 0, 0, false],\n  0x9e: ['SWAP', 3, 0, 0, false],\n  0x9f: ['SWAP', 3, 0, 0, false],\n\n  0xa0: ['LOG', 375, 2, 0, false],\n  0xa1: ['LOG', 375, 3, 0, false],\n  0xa2: ['LOG', 375, 4, 0, false],\n  0xa3: ['LOG', 375, 5, 0, false],\n  0xa4: ['LOG', 375, 6, 0, false],\n\n  // '0xf0' range - closures\n  0xf0: ['CREATE', 32000, 3, 1, true, true],\n  0xf1: ['CALL', 700, 7, 1, true, true],\n  0xf2: ['CALLCODE', 700, 7, 1, true, true],\n  0xf3: ['RETURN', 0, 2, 0, false],\n  0xf4: ['DELEGATECALL', 700, 6, 1, true, true],\n  0xf5: ['CREATE2', 32000, 4, 1, true, true],\n  0xfa: ['STATICCALL', 700, 6, 1, true, true],\n  0xfd: ['REVERT', 0, 2, 0, false],\n\n  // '0x70', range - other\n  0xfe: ['INVALID', 0, 0, 0, false],\n  0xff: ['SELFDESTRUCT', 5000, 1, 0, false, true]\n};\n\nmodule.exports = function (op, full, freeLogs) {\n  var code = codes[op] ? codes[op] : ['INVALID', 0, 0, 0, false, false];\n  var opcode = code[0];\n\n  if (full) {\n    if (opcode === 'LOG') {\n      opcode += op - 0xa0;\n    }\n\n    if (opcode === 'PUSH') {\n      opcode += op - 0x5f;\n    }\n\n    if (opcode === 'DUP') {\n      opcode += op - 0x7f;\n    }\n\n    if (opcode === 'SWAP') {\n      opcode += op - 0x8f;\n    }\n  }\n\n  var fee = code[1];\n\n  if (freeLogs) {\n    if (opcode === 'LOG') {\n      fee = 0;\n    }\n  }\n\n  return { name: opcode, opcode: op, fee: fee, in: code[2], out: code[3], dynamic: code[4], async: code[5] };\n};","import STOP from '../opcodes/stop';\nimport ADD from '../opcodes/add';\nimport MUL from '../opcodes/mul';\nimport SUB from '../opcodes/sub';\nimport DIV from '../opcodes/div';\nimport MOD from '../opcodes/mod';\nimport ADDMOD from '../opcodes/addmod';\nimport MULMOD from '../opcodes/mulmod';\nimport EXP from '../opcodes/exp';\nimport SIGNEXTEND from '../opcodes/signextend';\nimport LT from '../opcodes/lt';\nimport GT from '../opcodes/gt';\nimport EQ from '../opcodes/eq';\nimport ISZERO from '../opcodes/iszero';\nimport AND from '../opcodes/and';\nimport OR from '../opcodes/or';\nimport XOR from '../opcodes/xor';\nimport NOT from '../opcodes/not';\nimport BYTE from '../opcodes/byte';\nimport SHL from '../opcodes/shl';\nimport SHR from '../opcodes/shr';\nimport SAR from '../opcodes/sar';\nimport SHA3 from '../opcodes/sha3';\nimport ADDRESS from '../opcodes/address';\nimport BALANCE from '../opcodes/balance';\nimport ORIGIN from '../opcodes/origin';\nimport CALLER from '../opcodes/caller';\nimport CALLVALUE from '../opcodes/callvalue';\nimport CALLDATALOAD from '../opcodes/calldataload';\nimport CALLDATASIZE from '../opcodes/calldatasize';\nimport CALLDATACOPY from '../opcodes/calldatacopy';\nimport CODESIZE from '../opcodes/codesize';\nimport CODECOPY from '../opcodes/codecopy';\nimport GASPRICE from '../opcodes/gasprice';\nimport EXTCODESIZE from '../opcodes/extcodesize';\nimport EXTCODECOPY from '../opcodes/extcodecopy';\nimport RETURNDATASIZE from '../opcodes/returndatasize';\nimport RETURNDATACOPY from '../opcodes/returndatacopy';\nimport EXTCODEHASH from '../opcodes/extcodehash';\nimport BLOCKHASH from '../opcodes/blockhash';\nimport COINBASE from '../opcodes/coinbase';\nimport TIMESTAMP from '../opcodes/timestamp';\nimport NUMBER from '../opcodes/number';\nimport DIFFICULTY from '../opcodes/difficulty';\nimport GASLIMIT from '../opcodes/gaslimit';\nimport POP from '../opcodes/pop';\nimport MLOAD from '../opcodes/mload';\nimport MSTORE from '../opcodes/mstore';\nimport SLOAD from '../opcodes/sload';\nimport SSTORE from '../opcodes/sstore';\nimport JUMP from '../opcodes/jump';\nimport JUMPI from '../opcodes/jumpi';\nimport PC from '../opcodes/pc';\nimport MSIZE from '../opcodes/msize';\nimport GAS from '../opcodes/gas';\nimport JUMPDEST from '../opcodes/jumpdest';\nimport PUSH from '../opcodes/push';\nimport DUP from '../opcodes/dup';\nimport SWAP from '../opcodes/swap';\nimport LOG from '../opcodes/log';\nimport CREATE from '../opcodes/create';\nimport CALL from '../opcodes/call';\nimport CALLCODE from '../opcodes/callcode';\nimport RETURN from '../opcodes/return';\nimport DELEGATECALL from '../opcodes/delegatecall';\nimport CREATE2 from '../opcodes/create2';\nimport STATICCALL from '../opcodes/staticcall';\nimport REVERT from '../opcodes/revert';\nimport INVALID from '../opcodes/invalid';\nimport SELFDESTRUCT from '../opcodes/selfdestruct';\n\nexport default {\n    STOP,\n    ADD,\n    MUL,\n    SUB,\n    DIV,\n    SDIV: DIV,\n    MOD,\n    SMOD: MOD,\n    ADDMOD,\n    MULMOD,\n    EXP,\n    SIGNEXTEND,\n    LT,\n    GT,\n    SLT: LT,\n    SGT: GT,\n    EQ,\n    ISZERO,\n    AND,\n    OR,\n    XOR,\n    NOT,\n    BYTE,\n    SHL,\n    SHR,\n    SAR,\n    SHA3,\n    ADDRESS,\n    BALANCE,\n    ORIGIN,\n    CALLER,\n    CALLVALUE,\n    CALLDATALOAD,\n    CALLDATASIZE,\n    CALLDATACOPY,\n    CODESIZE,\n    CODECOPY,\n    GASPRICE,\n    EXTCODESIZE,\n    EXTCODECOPY,\n    RETURNDATASIZE,\n    RETURNDATACOPY,\n    EXTCODEHASH,\n    BLOCKHASH,\n    COINBASE,\n    TIMESTAMP,\n    NUMBER,\n    DIFFICULTY,\n    GASLIMIT,\n    POP,\n    MLOAD,\n    MSTORE,\n    MSTORE8: MSTORE,\n    SLOAD,\n    SSTORE,\n    JUMP,\n    JUMPI,\n    PC,\n    MSIZE,\n    GAS,\n    JUMPDEST,\n    PUSH1: PUSH,\n    PUSH2: PUSH,\n    PUSH3: PUSH,\n    PUSH4: PUSH,\n    PUSH5: PUSH,\n    PUSH6: PUSH,\n    PUSH7: PUSH,\n    PUSH8: PUSH,\n    PUSH9: PUSH,\n    PUSH10: PUSH,\n    PUSH11: PUSH,\n    PUSH12: PUSH,\n    PUSH13: PUSH,\n    PUSH14: PUSH,\n    PUSH15: PUSH,\n    PUSH16: PUSH,\n    PUSH17: PUSH,\n    PUSH18: PUSH,\n    PUSH19: PUSH,\n    PUSH20: PUSH,\n    PUSH21: PUSH,\n    PUSH22: PUSH,\n    PUSH23: PUSH,\n    PUSH24: PUSH,\n    PUSH25: PUSH,\n    PUSH26: PUSH,\n    PUSH27: PUSH,\n    PUSH28: PUSH,\n    PUSH29: PUSH,\n    PUSH30: PUSH,\n    PUSH31: PUSH,\n    PUSH32: PUSH,\n    DUP1: DUP,\n    DUP2: DUP,\n    DUP3: DUP,\n    DUP4: DUP,\n    DUP5: DUP,\n    DUP6: DUP,\n    DUP7: DUP,\n    DUP8: DUP,\n    DUP9: DUP,\n    DUP10: DUP,\n    DUP11: DUP,\n    DUP12: DUP,\n    DUP13: DUP,\n    DUP14: DUP,\n    DUP15: DUP,\n    DUP16: DUP,\n    SWAP1: SWAP,\n    SWAP2: SWAP,\n    SWAP3: SWAP,\n    SWAP4: SWAP,\n    SWAP5: SWAP,\n    SWAP6: SWAP,\n    SWAP7: SWAP,\n    SWAP8: SWAP,\n    SWAP9: SWAP,\n    SWAP10: SWAP,\n    SWAP11: SWAP,\n    SWAP12: SWAP,\n    SWAP13: SWAP,\n    SWAP14: SWAP,\n    SWAP15: SWAP,\n    SWAP16: SWAP,\n    LOG0: LOG,\n    LOG1: LOG,\n    LOG2: LOG,\n    LOG3: LOG,\n    LOG4: LOG,\n    CREATE,\n    CALL,\n    CALLCODE,\n    RETURN,\n    DELEGATECALL,\n    CREATE2,\n    STATICCALL,\n    REVERT,\n    INVALID,\n    SELFDESTRUCT\n};\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class STOP {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'STOP';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'return;';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.halted = true;\r\n    state.instructions.push(new STOP());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class DIV {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'DIV';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' / ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.divide(right));\r\n    } else if (BigNumber.isInstance(right) && right.equals(1)) {\r\n        state.stack.push(left);\r\n    } else {\r\n        state.stack.push(new DIV(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport { ADD } from './add';\r\nimport { MOD } from './mod';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    const mod = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right) && BigNumber.isInstance(mod)) {\r\n        state.stack.push(left.add(right).mod(mod));\r\n    } else if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(new MOD(left.add(right), mod));\r\n    } else {\r\n        state.stack.push(new MOD(new ADD(left, right), mod));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport { MUL } from './mul';\r\nimport { MOD } from './mod';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    const mod = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right) && BigNumber.isInstance(mod)) {\r\n        state.stack.push(left.multiply(right).mod(mod));\r\n    } else if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(new MOD(left.multiply(right), mod));\r\n    } else {\r\n        state.stack.push(new MOD(new MUL(left, right), mod));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class EXP {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'EXP';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' ** ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.pow(right));\r\n    } else {\r\n        state.stack.push(new EXP(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport { SHL } from './shl';\r\nimport { SAR } from './sar';\r\nimport { SUB } from './sub';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(\r\n            right.shiftLeft(BigNumber(32).subtract(left)).shiftRight(BigNumber(32).subtract(left))\r\n        );\r\n    } else if (BigNumber.isInstance(left)) {\r\n        state.stack.push(\r\n            new SAR(new SHL(right, BigNumber(32).subtract(left)), BigNumber(32).subtract(left))\r\n        );\r\n    } else {\r\n        state.stack.push(\r\n            new SAR(new SHL(right, new SUB(BigNumber(32), left)), new SUB(BigNumber(32), left))\r\n        );\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class SIG {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly hash: string;\r\n\r\n    constructor(hash: string) {\r\n        this.name = 'SIG';\r\n        this.wrapped = false;\r\n        this.hash = hash;\r\n    }\r\n\r\n    toString() {\r\n        return 'msg.sig == ' + this.hash;\r\n    }\r\n}\r\n\r\nexport class EQ {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'EQ';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' == ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    let left = state.stack.pop();\r\n    let right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(BigNumber(left.equals(right) === true ? 1 : 0));\r\n    } else {\r\n        if (\r\n            BigNumber.isInstance(left) &&\r\n            right.name === 'DIV' &&\r\n            BigNumber.isInstance(right.right)\r\n        ) {\r\n            left = left.multiply(right.right);\r\n            right = right.left;\r\n        }\r\n        if (\r\n            BigNumber.isInstance(right) &&\r\n            left.name === 'DIV' &&\r\n            BigNumber.isInstance(left.right)\r\n        ) {\r\n            right = right.multiply(left.right);\r\n            left = left.left;\r\n        }\r\n        if (\r\n            BigNumber.isInstance(left) &&\r\n            /^[0]+$/.test(left.toString(16).substring(8)) &&\r\n            right.name === 'CALLDATALOAD' &&\r\n            right.location.equals(0)\r\n        ) {\r\n            state.stack.push(\r\n                new SIG(\r\n                    '0'.repeat(64 - left.toString(16).length) +\r\n                        left.toString(16).substring(0, 8 - (64 - left.toString(16).length))\r\n                )\r\n            );\r\n        } else if (\r\n            BigNumber.isInstance(right) &&\r\n            /^[0]+$/.test(right.toString(16).substring(8)) &&\r\n            left.name === 'CALLDATALOAD' &&\r\n            left.location.equals(0)\r\n        ) {\r\n            state.stack.push(\r\n                new SIG(\r\n                    '0'.repeat(64 - right.toString(16).length) +\r\n                        right.toString(16).substring(0, 8 - (64 - right.toString(16).length))\r\n                )\r\n            );\r\n        } else {\r\n            state.stack.push(new EQ(left, right));\r\n        }\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport { LT } from './lt';\r\nimport { GT } from './gt';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class ISZERO {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly item: any;\r\n\r\n    constructor(item: any) {\r\n        this.name = 'ISZERO';\r\n        this.wrapped = true;\r\n        this.item = item;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.item) + ' == 0';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const item = state.stack.pop();\r\n    if (BigNumber.isInstance(item)) {\r\n        state.stack.push(BigNumber(item.isZero() === true ? 1 : 0));\r\n    } else if (item.name === 'LT') {\r\n        if (item.equal) {\r\n            state.stack.push(new GT(item.left, item.right));\r\n        } else {\r\n            state.stack.push(new GT(item.left, item.right, true));\r\n        }\r\n    } else if (item.name === 'GT') {\r\n        if (item.equal) {\r\n            state.stack.push(new LT(item.left, item.right));\r\n        } else {\r\n            state.stack.push(new LT(item.left, item.right, true));\r\n        }\r\n    } else if (item instanceof ISZERO) {\r\n        state.stack.push(item.item);\r\n    } else {\r\n        state.stack.push(new ISZERO(item));\r\n    }\r\n    /* == -> != */\r\n    /* != -> == */\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class AND {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'AND';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' && ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.and(right));\r\n    } else if (BigNumber.isInstance(left) && /^[f]+$/.test(left.toString(16))) {\r\n        right.size = left.toString(16).length;\r\n        state.stack.push(right);\r\n    } else if (BigNumber.isInstance(right) && /^[f]+$/.test(right.toString(16))) {\r\n        left.size = right.toString(16).length;\r\n        state.stack.push(left);\r\n        /*} else if (\r\n        BigNumber.isInstance(left) &&\r\n        left.equals('1461501637330902918203684832716283019655932542975')\r\n    ) {*/\r\n        /* 2 ** 160 */\r\n        /*    state.stack.push(right);\r\n    } else if (\r\n        BigNumber.isInstance(right) &&\r\n        right.equals('1461501637330902918203684832716283019655932542975')\r\n    ) {*/\r\n        /* 2 ** 160 */\r\n        /*    state.stack.push(left);*/\r\n    } else if (\r\n        BigNumber.isInstance(left) &&\r\n        right instanceof AND &&\r\n        BigNumber.isInstance(right.left) &&\r\n        left.equals(right.left)\r\n    ) {\r\n        state.stack.push(right.right);\r\n    } else {\r\n        state.stack.push(new AND(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class OR {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'OR';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' || ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.or(right));\r\n    } else {\r\n        state.stack.push(new OR(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class XOR {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'XOR';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' ^ ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.xor(right));\r\n    } else {\r\n        state.stack.push(new XOR(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class NOT {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly item: any;\r\n\r\n    constructor(item: any) {\r\n        this.name = 'AND';\r\n        this.wrapped = true;\r\n        this.item = item;\r\n    }\r\n\r\n    toString() {\r\n        return '~' + stringify(this.item);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const item = state.stack.pop();\r\n    if (BigNumber.isInstance(item)) {\r\n        state.stack.push(item.not());\r\n    } else {\r\n        state.stack.push(new NOT(item));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class BYTE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly position: any;\r\n    readonly data: any;\r\n\r\n    constructor(position: any, data: any) {\r\n        this.name = 'BYTE';\r\n        this.wrapped = true;\r\n        this.position = position;\r\n        this.data = data;\r\n    }\r\n\r\n    toString() {\r\n        return '(' + stringify(this.data) + ' >> ' + stringify(this.position) + ') & 1';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const position = state.stack.pop();\r\n    const data = state.stack.pop();\r\n    if (BigNumber.isInstance(data) && BigNumber.isInstance(position)) {\r\n        state.stack.push(data.shiftRight(position).and(1));\r\n    } else {\r\n        state.stack.push(new BYTE(position, data));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class SHR {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly left: any;\r\n    readonly right: any;\r\n\r\n    constructor(left: any, right: any) {\r\n        this.name = 'SHR';\r\n        this.wrapped = true;\r\n        this.left = left;\r\n        this.right = right;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.left) + ' >>> ' + stringify(this.right);\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const left = state.stack.pop();\r\n    const right = state.stack.pop();\r\n    if (BigNumber.isInstance(left) && BigNumber.isInstance(right)) {\r\n        state.stack.push(left.shiftRight(right));\r\n    } else {\r\n        state.stack.push(new SHR(left, right));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport { MLOAD } from './mload';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class SHA3 {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly memoryStart?: any;\r\n    readonly memoryLength?: any;\r\n    readonly items: any;\r\n\r\n    constructor(items: any, memoryStart?: any, memoryLength?: any) {\r\n        this.name = 'SHA3';\r\n        this.wrapped = false;\r\n        if (memoryStart && memoryLength) {\r\n            this.memoryStart = memoryStart;\r\n            this.memoryLength = memoryLength;\r\n        } else {\r\n            this.items = items;\r\n        }\r\n    }\r\n\r\n    toString() {\r\n        if (this.items) {\r\n            return 'keccak256(' + this.items.map((item: any) => stringify(item)).join(', ') + ')';\r\n        } else {\r\n            return (\r\n                'keccak256(memory[' +\r\n                stringify(this.memoryStart) +\r\n                ':(' +\r\n                stringify(this.memoryStart) +\r\n                '+' +\r\n                stringify(this.memoryLength) +\r\n                ')])'\r\n            );\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    if (BigNumber.isInstance(memoryStart) && BigNumber.isInstance(memoryLength)) {\r\n        const items = [];\r\n        for (\r\n            let i = memoryStart.toJSNumber();\r\n            i < memoryStart.add(memoryLength).toJSNumber();\r\n            i += 32\r\n        ) {\r\n            if (i in state.memory) {\r\n                items.push(state.memory[i]);\r\n            } else {\r\n                items.push(new MLOAD(i));\r\n            }\r\n        }\r\n        state.stack.push(new SHA3(items));\r\n    } else {\r\n        state.stack.push(new SHA3([], memoryStart, memoryLength));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class ADDRESS {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'ADDRESS';\r\n        this.type = 'address';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'this';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new ADDRESS());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class BALANCE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly address: any;\r\n\r\n    constructor(address: any) {\r\n        this.name = 'BALANCE';\r\n        this.wrapped = true;\r\n        this.address = address;\r\n    }\r\n\r\n    toString() {\r\n        return stringify(this.address) + '.balance';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const address = state.stack.pop();\r\n    state.stack.push(new BALANCE(address));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class ORIGIN {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'ORIGIN';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'tx.origin';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new ORIGIN());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class CALLER {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'CALLER';\r\n        this.name = 'address';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'msg.sender';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new CALLER());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class CALLVALUE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'CALLVALUE';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'msg.value';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new CALLVALUE());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class CALLDATALOAD {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly returntype?: string;\r\n    readonly wrapped: boolean;\r\n    readonly location: any;\r\n\r\n    constructor(location: any) {\r\n        this.name = 'CALLDATALOAD';\r\n        this.wrapped = false;\r\n        this.location = location;\r\n    }\r\n\r\n    toString() {\r\n        if (BigNumber.isInstance(this.location) && this.location.isZero()) {\r\n            return 'msg.data';\r\n        } else if (\r\n            BigNumber.isInstance(this.location) &&\r\n            this.location\r\n                .subtract(4)\r\n                .mod(32)\r\n                .isZero()\r\n        ) {\r\n            return (\r\n                '_arg' +\r\n                this.location\r\n                    .subtract(4)\r\n                    .divide(32)\r\n                    .toString()\r\n            );\r\n        } else {\r\n            return 'msg.data[' + stringify(this.location) + ']';\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const startLocation = state.stack.pop();\r\n    state.stack.push(new CALLDATALOAD(startLocation));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class CALLDATASIZE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'CALLDATASIZE';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'msg.data.length';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new CALLDATASIZE());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class CALLDATACOPY {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly startLocation: any;\r\n    readonly copyLength: any;\r\n\r\n    constructor(startLocation: any, copyLength: any) {\r\n        this.name = 'CALLDATACOPY';\r\n        this.wrapped = true;\r\n        this.startLocation = startLocation;\r\n        this.copyLength = copyLength;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            'msg.data[' +\r\n            this.startLocation +\r\n            ':(' +\r\n            this.startLocation +\r\n            '+' +\r\n            this.copyLength +\r\n            ')];'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const memoryLocation = state.stack.pop();\r\n    const startLocation = state.stack.pop();\r\n    const copyLength = state.stack.pop();\r\n    state.memory[memoryLocation] = new CALLDATACOPY(startLocation, copyLength);\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class CODESIZE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'CODESIZE';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'this.code.length';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new CODESIZE());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class CODECOPY {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly startLocation: any;\r\n    readonly copyLength: any;\r\n\r\n    constructor(startLocation: any, copyLength: any) {\r\n        this.name = 'CODECOPY';\r\n        this.wrapped = true;\r\n        this.startLocation = startLocation;\r\n        this.copyLength = copyLength;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            'this.code[' +\r\n            stringify(this.startLocation) +\r\n            ':(' +\r\n            stringify(this.startLocation) +\r\n            '+' +\r\n            stringify(this.copyLength) +\r\n            ')]'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const memoryLocation = state.stack.pop();\r\n    const startLocation = state.stack.pop();\r\n    const copyLength = state.stack.pop();\r\n    state.memory[memoryLocation] = new CODECOPY(startLocation, copyLength);\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class GASPRICE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'GASPRICE';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'tx.gasprice';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new GASPRICE());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class EXTCODESIZE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly address: any;\r\n\r\n    constructor(address: any) {\r\n        this.name = 'EXTCODESIZE';\r\n        this.wrapped = true;\r\n        this.address = address;\r\n    }\r\n\r\n    toString() {\r\n        return 'address(' + stringify(this.address) + ').code.length';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const address = state.stack.pop();\r\n    state.stack.push(new EXTCODESIZE(address));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class EXTCODECOPY {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly address: any;\r\n    readonly startLocation: any;\r\n    readonly copyLength: any;\r\n\r\n    constructor(address: any, startLocation: any, copyLength: any) {\r\n        this.name = 'EXTCODECOPY';\r\n        this.wrapped = true;\r\n        this.address = address;\r\n        this.startLocation = startLocation;\r\n        this.copyLength = copyLength;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            'address(' +\r\n            stringify(this.address) +\r\n            ').code[' +\r\n            stringify(this.startLocation) +\r\n            ':(' +\r\n            stringify(this.startLocation) +\r\n            '+' +\r\n            stringify(this.copyLength) +\r\n            ')]'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const address = state.stack.pop();\r\n    const memoryLocation = state.stack.pop();\r\n    const startLocation = state.stack.pop();\r\n    const copyLength = state.stack.pop();\r\n    state.memory[memoryLocation] = new EXTCODECOPY(address, startLocation, copyLength);\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class RETURNDATASIZE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'RETURNDATASIZE';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'output.length';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new RETURNDATASIZE());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class RETURNDATACOPY {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly returnDataPosition: any;\r\n    readonly returnDataSize: any;\r\n\r\n    constructor(returnDataPosition: any, returnDataSize: any) {\r\n        this.name = 'RETURNDATACOPY';\r\n        this.wrapped = true;\r\n        this.returnDataPosition = returnDataPosition;\r\n        this.returnDataSize = returnDataSize;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            'output[' +\r\n            stringify(this.returnDataPosition) +\r\n            ':(' +\r\n            stringify(this.returnDataPosition) +\r\n            '+' +\r\n            stringify(this.returnDataSize) +\r\n            ')]'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const memoryPosition = state.stack.pop();\r\n    const returnDataPosition = state.stack.pop();\r\n    const returnDataSize = state.stack.pop();\r\n    state.memory[memoryPosition] = new RETURNDATACOPY(returnDataPosition, returnDataSize);\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class EXTCODEHASH {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly address: any;\r\n\r\n    constructor(address: any) {\r\n        this.name = 'EXTCODEHASH';\r\n        this.wrapped = true;\r\n        this.address = address;\r\n    }\r\n\r\n    toString() {\r\n        return 'keccak256(address(' + stringify(this.address) + ').code)';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const address = state.stack.pop();\r\n    state.stack.push(new EXTCODEHASH(address));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class BLOCKHASH {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly number: any;\r\n\r\n    constructor(blockNumber: any) {\r\n        this.name = 'BLOCKHASH';\r\n        this.wrapped = true;\r\n        this.number = blockNumber;\r\n    }\r\n\r\n    toString() {\r\n        return 'block.blockhash(' + stringify(this.number) + ')';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const blockNumber = state.stack.pop();\r\n    state.stack.push(new BLOCKHASH(blockNumber));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class COINBASE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'COINBASE';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'block.coinbase';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new COINBASE());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class TIMESTAMP {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'TIMESTAMP';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'block.timestamp';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new TIMESTAMP());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class NUMBER {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'NUMBER';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'block.number';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new NUMBER());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class DIFFICULTY {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'DIFFICULTY';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'block.difficulty';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new DIFFICULTY());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class GASLIMIT {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'GASLIMIT';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'block.gaslimit';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new GASLIMIT());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.pop();\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class MSTORE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly location: any;\r\n    readonly data: any;\r\n\r\n    constructor(location: any, data: any) {\r\n        this.name = 'MSTORE';\r\n        this.wrapped = true;\r\n        this.location = location;\r\n        this.data = data;\r\n    }\r\n\r\n    toString() {\r\n        return 'memory[' + stringify(this.location) + '] = ' + stringify(this.data) + ';';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const storeLocation = state.stack.pop();\r\n    const storeData = state.stack.pop();\r\n    if (BigNumber.isInstance(storeLocation)) {\r\n        state.memory[storeLocation.toJSNumber()] = storeData;\r\n    } else {\r\n        state.instructions.push(new MSTORE(storeLocation, storeData));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nconst parseMapping = (...items: any[]) => {\r\n    const mappings: any = [];\r\n    items.forEach((item2: any) => {\r\n        if (item2.name === 'SHA3' && item2.items) {\r\n            mappings.push(...parseMapping(...item2.items));\r\n        } else {\r\n            mappings.push(item2);\r\n        }\r\n    });\r\n    return mappings;\r\n};\r\n\r\nexport class MappingLoad {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly location: any;\r\n    readonly count: any;\r\n    readonly items: any;\r\n    readonly structlocation?: any;\r\n    readonly mappings: any;\r\n\r\n    constructor(mappings: any, location: any, items: any, count: any, structlocation?: any) {\r\n        this.name = 'MappingLoad';\r\n        this.wrapped = false;\r\n        this.location = location;\r\n        this.count = count;\r\n        this.items = items;\r\n        this.structlocation = structlocation;\r\n        this.mappings = mappings;\r\n    }\r\n\r\n    toString() {\r\n        let mappingName = 'mapping' + (this.count + 1);\r\n        if (this.location in this.mappings() && this.mappings()[this.location].name) {\r\n            mappingName = this.mappings()[this.location].name;\r\n        }\r\n        if (this.structlocation) {\r\n            return (\r\n                mappingName +\r\n                this.items.map((item: any) => '[' + stringify(item) + ']').join('') +\r\n                '[' +\r\n                this.structlocation.toString() +\r\n                ']'\r\n            );\r\n        } else {\r\n            return (\r\n                mappingName + this.items.map((item: any) => '[' + stringify(item) + ']').join('')\r\n            );\r\n        }\r\n    }\r\n}\r\n\r\nexport class SLOAD {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly location: any;\r\n    readonly variables: any;\r\n\r\n    constructor(location: any, variables: any) {\r\n        this.name = 'SLOAD';\r\n        this.wrapped = false;\r\n        this.location = location;\r\n        this.variables = variables;\r\n    }\r\n\r\n    toString() {\r\n        if (BigNumber.isInstance(this.location) && this.location.toString() in this.variables()) {\r\n            if (this.variables()[this.location.toString()].label) {\r\n                return this.variables()[this.location.toString()].label;\r\n            } else {\r\n                return (\r\n                    'var' + (Object.keys(this.variables()).indexOf(this.location.toString()) + 1)\r\n                );\r\n            }\r\n        } else {\r\n            return 'storage[' + stringify(this.location) + ']';\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const storeLocation = state.stack.pop();\r\n    if (storeLocation.name === 'SHA3') {\r\n        const mappingItems = parseMapping(...storeLocation.items);\r\n        const mappingLocation = mappingItems.find((mappingItem: any) =>\r\n            BigNumber.isInstance(mappingItem)\r\n        );\r\n        const mappingParts = mappingItems.filter(\r\n            (mappingItem: any) => !BigNumber.isInstance(mappingItem)\r\n        );\r\n        if (mappingLocation && mappingParts.length > 0) {\r\n            if (!(mappingLocation in state.mappings)) {\r\n                state.mappings[mappingLocation] = {\r\n                    name: false,\r\n                    structs: [],\r\n                    keys: [],\r\n                    values: []\r\n                };\r\n            }\r\n            state.mappings[mappingLocation].keys.push(mappingParts);\r\n            state.stack.push(\r\n                new MappingLoad(\r\n                    () => state.mappings,\r\n                    mappingLocation,\r\n                    mappingParts,\r\n                    Object.keys(state.mappings).indexOf(mappingLocation.toString())\r\n                )\r\n            );\r\n        } else {\r\n            state.stack.push(new SLOAD(storeLocation, () => state.variables));\r\n        }\r\n    } else if (\r\n        storeLocation.name === 'ADD' &&\r\n        storeLocation.left.name === 'SHA3' &&\r\n        BigNumber.isInstance(storeLocation.right)\r\n    ) {\r\n        const mappingItems = parseMapping(...storeLocation.left.items);\r\n        const mappingLocation = mappingItems.find((mappingItem: any) =>\r\n            BigNumber.isInstance(mappingItem)\r\n        );\r\n        const mappingParts = mappingItems.filter(\r\n            (mappingItem: any) => !BigNumber.isInstance(mappingItem)\r\n        );\r\n        if (mappingLocation && mappingParts.length > 0) {\r\n            if (!(mappingLocation in state.mappings)) {\r\n                state.mappings[mappingLocation] = {\r\n                    name: false,\r\n                    structs: [],\r\n                    keys: [],\r\n                    values: []\r\n                };\r\n            }\r\n            state.mappings[mappingLocation].keys.push(mappingParts);\r\n            state.stack.push(\r\n                new MappingLoad(\r\n                    () => state.mappings,\r\n                    mappingLocation,\r\n                    mappingParts,\r\n                    Object.keys(state.mappings).indexOf(mappingLocation.toString()),\r\n                    storeLocation.right\r\n                )\r\n            );\r\n        } else {\r\n            state.stack.push(new SLOAD(storeLocation, () => state.variables));\r\n        }\r\n    } else if (\r\n        storeLocation.name === 'ADD' &&\r\n        BigNumber.isInstance(storeLocation.left) &&\r\n        storeLocation.right.name === 'SHA3'\r\n    ) {\r\n        const mappingItems = parseMapping(...storeLocation.right.items);\r\n        const mappingLocation = mappingItems.find((mappingItem: any) =>\r\n            BigNumber.isInstance(mappingItem)\r\n        );\r\n        const mappingParts = mappingItems.filter(\r\n            (mappingItem: any) => !BigNumber.isInstance(mappingItem)\r\n        );\r\n        if (mappingLocation && mappingParts.length > 0) {\r\n            if (!(mappingLocation in state.mappings)) {\r\n                state.mappings[mappingLocation] = {\r\n                    name: false,\r\n                    structs: [],\r\n                    keys: [],\r\n                    values: []\r\n                };\r\n            }\r\n            state.mappings[mappingLocation].keys.push(mappingParts);\r\n            state.stack.push(\r\n                new MappingLoad(\r\n                    () => state.mappings,\r\n                    mappingLocation,\r\n                    mappingParts,\r\n                    Object.keys(state.mappings).indexOf(mappingLocation.toString()),\r\n                    storeLocation.left\r\n                )\r\n            );\r\n        } else {\r\n            state.stack.push(new SLOAD(storeLocation, () => state.variables));\r\n        }\r\n    } else {\r\n        state.stack.push(new SLOAD(storeLocation, () => state.variables));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\nimport { Variable } from './jumpi';\r\n\r\nconst parseMapping = (...items: any[]) => {\r\n    const mappings: any = [];\r\n    items.forEach((item2: any) => {\r\n        if (item2.name === 'SHA3' && item2.items) {\r\n            mappings.push(...parseMapping(...item2.items));\r\n        } else {\r\n            mappings.push(item2);\r\n        }\r\n    });\r\n    return mappings;\r\n};\r\n\r\nexport class MappingStore {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly location: any;\r\n    readonly count: any;\r\n    readonly items: any;\r\n    readonly data: any;\r\n    readonly structlocation?: any;\r\n    readonly mappings: any;\r\n\r\n    constructor(\r\n        mappings: any,\r\n        location: any,\r\n        items: any,\r\n        data: any,\r\n        count: any,\r\n        structlocation?: any\r\n    ) {\r\n        this.name = 'MappingStore';\r\n        this.wrapped = false;\r\n        this.location = location;\r\n        this.items = items;\r\n        this.data = data;\r\n        this.count = count;\r\n        this.structlocation = structlocation;\r\n        this.mappings = mappings;\r\n    }\r\n\r\n    toString() {\r\n        let mappingName = 'mapping' + (this.count + 1);\r\n        if (this.location in this.mappings() && this.mappings()[this.location].name) {\r\n            mappingName = this.mappings()[this.location].name;\r\n        }\r\n        if (\r\n            this.data.name === 'ADD' &&\r\n            this.data.right.name === 'MappingLoad' &&\r\n            stringify(this.data.right.location) === stringify(this.location)\r\n        ) {\r\n            return (\r\n                mappingName +\r\n                this.items.map((item: any) => '[' + stringify(item) + ']').join('') +\r\n                ' += ' +\r\n                stringify(this.data.left) +\r\n                ';'\r\n            );\r\n        } else if (\r\n            this.data.name === 'SUB' &&\r\n            this.data.left.name === 'MappingLoad' &&\r\n            stringify(this.data.left.location) === stringify(this.location)\r\n        ) {\r\n            return (\r\n                mappingName +\r\n                this.items.map((item: any) => '[' + stringify(item) + ']').join('') +\r\n                ' -= ' +\r\n                stringify(this.data.right) +\r\n                ';'\r\n            );\r\n        } else {\r\n            return (\r\n                mappingName +\r\n                this.items.map((item: any) => '[' + stringify(item) + ']').join('') +\r\n                ' = ' +\r\n                stringify(this.data) +\r\n                ';'\r\n            );\r\n        }\r\n    }\r\n}\r\n\r\nexport class SSTORE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly location: any;\r\n    readonly data: any;\r\n    readonly variables: any;\r\n\r\n    constructor(location: any, data: any, variables: any) {\r\n        this.name = 'SSTORE';\r\n        this.wrapped = true;\r\n        this.location = location;\r\n        this.data = data;\r\n        this.variables = variables;\r\n        if (BigNumber.isInstance(this.location) && this.location.toString() in this.variables()) {\r\n            this.variables()[this.location.toString()].types.push(() => this.data.type);\r\n        } else if (\r\n            BigNumber.isInstance(this.location) &&\r\n            !(this.location.toString() in this.variables())\r\n        ) {\r\n            this.variables()[this.location.toString()] = new Variable(false, [\r\n                () => this.data.type\r\n            ]);\r\n        }\r\n    }\r\n\r\n    toString() {\r\n        let variableName = 'storage[' + stringify(this.location) + ']';\r\n        if (BigNumber.isInstance(this.location) && this.location.toString() in this.variables()) {\r\n            if (this.variables()[this.location.toString()].label) {\r\n                variableName = this.variables()[this.location.toString()].label;\r\n            } else {\r\n                variableName =\r\n                    'var' + (Object.keys(this.variables()).indexOf(this.location.toString()) + 1);\r\n            }\r\n        }\r\n        if (\r\n            this.data.name === 'ADD' &&\r\n            this.data.right.name === 'SLOAD' &&\r\n            stringify(this.data.right.location) === stringify(this.location)\r\n        ) {\r\n            return variableName + ' += ' + stringify(this.data.left) + ';';\r\n        } else if (\r\n            this.data.name === 'SUB' &&\r\n            this.data.left.name === 'SLOAD' &&\r\n            stringify(this.data.left.location) === stringify(this.location)\r\n        ) {\r\n            return variableName + ' -= ' + stringify(this.data.right) + ';';\r\n        } else {\r\n            return variableName + ' = ' + stringify(this.data) + ';';\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const storeLocation = state.stack.pop();\r\n    const storeData = state.stack.pop();\r\n    if (storeLocation.name === 'SHA3') {\r\n        const mappingItems = parseMapping(...storeLocation.items);\r\n        const mappingLocation = mappingItems.find((mappingItem: any) =>\r\n            BigNumber.isInstance(mappingItem)\r\n        );\r\n        const mappingParts = mappingItems.filter(\r\n            (mappingItem: any) => !BigNumber.isInstance(mappingItem)\r\n        );\r\n        if (mappingLocation && mappingParts.length > 0) {\r\n            if (!(mappingLocation in state.mappings)) {\r\n                state.mappings[mappingLocation] = {\r\n                    name: false,\r\n                    structs: [],\r\n                    keys: [],\r\n                    values: []\r\n                };\r\n            }\r\n            state.mappings[mappingLocation].keys.push(mappingParts);\r\n            state.mappings[mappingLocation].values.push(storeData);\r\n            state.instructions.push(\r\n                new MappingStore(\r\n                    () => state.mappings,\r\n                    mappingLocation,\r\n                    mappingParts,\r\n                    storeData,\r\n                    Object.keys(state.mappings).indexOf(mappingLocation.toString())\r\n                )\r\n            );\r\n        } else {\r\n            state.instructions.push(new SSTORE(storeLocation, storeData, () => state.variables));\r\n        }\r\n    } else if (\r\n        storeLocation.name === 'ADD' &&\r\n        storeLocation.left.name === 'SHA3' &&\r\n        BigNumber.isInstance(storeLocation.right)\r\n    ) {\r\n        const mappingItems = parseMapping(...storeLocation.left.items);\r\n        const mappingLocation = mappingItems.find((mappingItem: any) =>\r\n            BigNumber.isInstance(mappingItem)\r\n        );\r\n        const mappingParts = mappingItems.filter(\r\n            (mappingItem: any) => !BigNumber.isInstance(mappingItem)\r\n        );\r\n        if (mappingLocation && mappingParts.length > 0) {\r\n            if (!(mappingLocation in state.mappings)) {\r\n                state.mappings[mappingLocation] = {\r\n                    name: false,\r\n                    structs: [],\r\n                    keys: [],\r\n                    values: []\r\n                };\r\n            }\r\n            state.mappings[mappingLocation].keys.push(mappingParts);\r\n            state.instructions.push(\r\n                new MappingStore(\r\n                    () => state.mappings,\r\n                    mappingLocation,\r\n                    mappingParts,\r\n                    storeData,\r\n                    Object.keys(state.mappings).indexOf(mappingLocation.toString()),\r\n                    storeLocation.right\r\n                )\r\n            );\r\n        } else {\r\n            state.instructions.push(new SSTORE(storeLocation, storeData, () => state.variables));\r\n        }\r\n    } else if (\r\n        storeLocation.name === 'ADD' &&\r\n        BigNumber.isInstance(storeLocation.left) &&\r\n        storeLocation.right.name === 'SHA3'\r\n    ) {\r\n        const mappingItems = parseMapping(...storeLocation.right.items);\r\n        const mappingLocation = mappingItems.find((mappingItem: any) =>\r\n            BigNumber.isInstance(mappingItem)\r\n        );\r\n        const mappingParts = mappingItems.filter(\r\n            (mappingItem: any) => !BigNumber.isInstance(mappingItem)\r\n        );\r\n        if (mappingLocation && mappingParts.length > 0) {\r\n            if (!(mappingLocation in state.mappings)) {\r\n                state.mappings[mappingLocation] = {\r\n                    name: false,\r\n                    structs: [],\r\n                    keys: [],\r\n                    values: []\r\n                };\r\n            }\r\n            state.mappings[mappingLocation].keys.push(mappingParts);\r\n            state.instructions.push(\r\n                new MappingStore(\r\n                    () => state.mappings,\r\n                    mappingLocation,\r\n                    mappingParts,\r\n                    storeData,\r\n                    Object.keys(state.mappings).indexOf(mappingLocation.toString()),\r\n                    storeLocation.left\r\n                )\r\n            );\r\n        } else {\r\n            state.instructions.push(new SSTORE(storeLocation, storeData, () => state.variables));\r\n        }\r\n    } else if (\r\n        false &&\r\n        BigNumber.isInstance(storeLocation) &&\r\n        storeLocation.toString() in state.variables &&\r\n        storeData.type &&\r\n        !state.variables[storeLocation.toString()].types.includes(storeData.type)\r\n    ) {\r\n        state.instructions.push(new SSTORE(storeLocation, storeData, () => state.variables));\r\n        state.variables[storeLocation.toString()].types.push(storeData.type);\r\n    } else {\r\n        state.instructions.push(new SSTORE(storeLocation, storeData, () => state.variables));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class JUMP {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly valid: boolean;\r\n    readonly location: any;\r\n\r\n    constructor(location: any, bad?: boolean) {\r\n        this.name = 'JUMP';\r\n        this.wrapped = false;\r\n        this.location = location;\r\n        this.valid = true;\r\n        if (bad) {\r\n            this.valid = false;\r\n        }\r\n    }\r\n\r\n    toString() {\r\n        if (!this.valid) {\r\n            return \"revert(\\\"Bad jump destination\\\");\";\r\n        } else {\r\n            return 'goto(' + stringify(this.location) + ');';\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const jumpLocation = state.stack.pop();\r\n    if (!BigNumber.isInstance(jumpLocation)) {\r\n        state.halted = true;\r\n        state.instructions.push(new JUMP(jumpLocation, true));\r\n    } else {\r\n        const opcodes = state.getOpcodes();\r\n        const jumpLocationData = opcodes.find((o: any) => o.pc === jumpLocation.toJSNumber());\r\n        if (!jumpLocationData) {\r\n            state.halted = true;\r\n            state.instructions.push(new JUMP(jumpLocation, true));\r\n        } else {\r\n            const jumpIndex = opcodes.indexOf(jumpLocationData);\r\n            if (!(opcode.pc + ':' + jumpLocation.toJSNumber() in state.jumps)) {\r\n                if (!jumpLocationData || jumpLocationData.name !== 'JUMPDEST') {\r\n                    state.halted = true;\r\n                    state.instructions.push(new JUMP(jumpLocation, true));\r\n                } else if (\r\n                    jumpLocationData &&\r\n                    jumpIndex >= 0 &&\r\n                    jumpLocationData.name === 'JUMPDEST'\r\n                ) {\r\n                    state.jumps[opcode.pc + ':' + jumpLocation.toJSNumber()] = true;\r\n                    state.pc = jumpIndex;\r\n                } else {\r\n                    state.halted = true;\r\n                    state.instructions.push(new JUMP(jumpLocation, true));\r\n                }\r\n            } else {\r\n                state.halted = true;\r\n                state.instructions.push(new JUMP(jumpLocation));\r\n            }\r\n        }\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(BigNumber(opcode.pc));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class MSIZE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'MSIZE';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'memory.length';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new MSIZE());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class GAS {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n\r\n    constructor() {\r\n        this.name = 'GAS';\r\n        this.wrapped = false;\r\n    }\r\n\r\n    toString() {\r\n        return 'gasleft()';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.stack.push(new GAS());\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    /* Empty */\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const pushDataLength = parseInt(opcode.name.replace('PUSH', ''), 10);\r\n    state.stack.push(BigNumber(opcode.pushData!.toString('hex'), 16));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const duplicateLocation = parseInt(opcode.name.replace('DUP', ''), 10) - 1;\r\n    state.stack.duplicate(duplicateLocation);\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const swapLocation = parseInt(opcode.name.replace('SWAP', ''), 10);\r\n    state.stack.swap(swapLocation);\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport { MLOAD } from './mload';\r\nimport * as eventHashes from '../../data/eventHashes.json';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\n\r\nexport class LOG {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly memoryStart?: any;\r\n    readonly memoryLength?: any;\r\n    readonly items?: any;\r\n    readonly topics: any;\r\n    readonly eventName?: string;\r\n\r\n    constructor(topics: any, items?: any, memoryStart?: any, memoryLength?: any) {\r\n        this.name = 'LOG';\r\n        this.wrapped = true;\r\n        this.topics = topics;\r\n        if (\r\n            this.topics.length > 0 &&\r\n            BigNumber.isInstance(this.topics[0]) &&\r\n            this.topics[0].toString(16) in eventHashes\r\n        ) {\r\n            this.eventName = (eventHashes as any)[this.topics[0].toString(16)].split('(')[0];\r\n            this.topics.shift();\r\n        }\r\n        if (this.memoryStart && this.memoryLength) {\r\n            this.memoryStart = memoryStart;\r\n            this.memoryLength = memoryLength;\r\n        } else {\r\n            this.items = items;\r\n        }\r\n    }\r\n\r\n    toString() {\r\n        if (this.eventName) {\r\n            return (\r\n                'emit ' + this.eventName + '(' + [...this.topics, ...this.items].join(', ') + ')'\r\n            );\r\n        } else {\r\n            return 'log(' + [...this.topics, ...this.items].join(', ') + ')';\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const topicsCount = parseInt(opcode.name.replace('LOG', ''), 10);\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    const topics = [];\r\n    for (let i = 0; i < topicsCount; i++) {\r\n        topics.push(state.stack.pop());\r\n    }\r\n    if (topics.length > 0) {\r\n        const eventTopic = topics[0].toString(16);\r\n        if (!(eventTopic in state.events)) {\r\n            state.events[eventTopic] = {};\r\n            state.events[eventTopic].indexedCount = topics.length - 1;\r\n            if (eventTopic in eventHashes) {\r\n                state.events[eventTopic].label = (eventHashes as any)[eventTopic];\r\n            }\r\n        }\r\n    }\r\n    if (BigNumber.isInstance(memoryStart) && BigNumber.isInstance(memoryLength)) {\r\n        const items = [];\r\n        for (\r\n            let i = memoryStart.toJSNumber();\r\n            i < memoryStart.add(memoryLength).toJSNumber();\r\n            i += 32\r\n        ) {\r\n            if (i in state.memory) {\r\n                items.push(state.memory[i]);\r\n            } else {\r\n                items.push(new MLOAD(i));\r\n            }\r\n        }\r\n        if (topics.length === 0) {\r\n            if (!('anonymous' in state.events)) {\r\n                state.events.anonymous = [];\r\n            }\r\n            state.events.anonymous.push({ items });\r\n        }\r\n        state.instructions.push(new LOG(topics, items));\r\n    } else {\r\n        state.instructions.push(new LOG(topics, [], memoryStart, memoryLength));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class CREATE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly memoryStart: any;\r\n    readonly memoryLength: any;\r\n    readonly value: any;\r\n\r\n    constructor(memoryStart: any, memoryLength: any, value: any) {\r\n        this.name = 'CREATE';\r\n        this.name = 'address';\r\n        this.wrapped = true;\r\n        this.memoryStart = memoryStart;\r\n        this.memoryLength = memoryLength;\r\n        this.value = value;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            '(new Contract(memory[' +\r\n            stringify(this.memoryStart) +\r\n            ':(' +\r\n            stringify(this.memoryStart) +\r\n            '+' +\r\n            stringify(this.memoryLength) +\r\n            ')]).value(' +\r\n            stringify(this.value) +\r\n            ')).address'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const value = state.stack.pop();\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    state.stack.push(new CREATE(memoryStart, memoryLength, value));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class CALL {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly gas: any;\r\n    readonly address: any;\r\n    readonly value: any;\r\n    readonly memoryStart: any;\r\n    readonly memoryLength: any;\r\n    readonly outputStart: any;\r\n    readonly outputLength: any;\r\n\r\n    constructor(\r\n        gas: any,\r\n        address: any,\r\n        value: any,\r\n        memoryStart: any,\r\n        memoryLength: any,\r\n        outputStart: any,\r\n        outputLength: any\r\n    ) {\r\n        this.name = 'CALL';\r\n        this.wrapped = true;\r\n        this.gas = gas;\r\n        this.address = address;\r\n        this.value = value;\r\n        this.memoryStart = memoryStart;\r\n        this.memoryLength = memoryLength;\r\n        this.outputStart = outputStart;\r\n        this.outputLength = outputLength;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            'call(' +\r\n            stringify(this.gas) +\r\n            ',' +\r\n            stringify(this.address) +\r\n            ',' +\r\n            stringify(this.value) +\r\n            ',' +\r\n            stringify(this.memoryStart) +\r\n            ',' +\r\n            stringify(this.memoryLength) +\r\n            ',' +\r\n            stringify(this.outputStart) +\r\n            ',' +\r\n            stringify(this.outputLength) +\r\n            ')'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const gas = state.stack.pop();\r\n    const address = state.stack.pop();\r\n    const value = state.stack.pop();\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    const outputStart = state.stack.pop();\r\n    const outputLength = state.stack.pop();\r\n    state.stack.push(\r\n        new CALL(gas, address, value, memoryStart, memoryLength, outputStart, outputLength)\r\n    );\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class CALLCODE {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly gas: any;\r\n    readonly address: any;\r\n    readonly value: any;\r\n    readonly memoryStart: any;\r\n    readonly memoryLength: any;\r\n    readonly outputStart: any;\r\n    readonly outputLength: any;\r\n\r\n    constructor(\r\n        gas: any,\r\n        address: any,\r\n        value: any,\r\n        memoryStart: any,\r\n        memoryLength: any,\r\n        outputStart: any,\r\n        outputLength: any\r\n    ) {\r\n        this.name = 'CALLCODE';\r\n        this.wrapped = true;\r\n        this.gas = gas;\r\n        this.address = address;\r\n        this.value = value;\r\n        this.memoryStart = memoryStart;\r\n        this.memoryLength = memoryLength;\r\n        this.outputStart = outputStart;\r\n        this.outputLength = outputLength;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            'callcode(' +\r\n            stringify(this.gas) +\r\n            ',' +\r\n            stringify(this.address) +\r\n            ',' +\r\n            stringify(this.value) +\r\n            ',' +\r\n            stringify(this.memoryStart) +\r\n            ',' +\r\n            stringify(this.memoryLength) +\r\n            ',' +\r\n            stringify(this.outputStart) +\r\n            ',' +\r\n            stringify(this.outputLength) +\r\n            ')'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const gas = state.stack.pop();\r\n    const address = state.stack.pop();\r\n    const value = state.stack.pop();\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    const outputStart = state.stack.pop();\r\n    const outputLength = state.stack.pop();\r\n    state.stack.push(\r\n        new CALLCODE(gas, address, value, memoryStart, memoryLength, outputStart, outputLength)\r\n    );\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport { MLOAD } from './mload';\r\nimport { hex2a } from '../utils/hex';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class RETURN {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly memoryStart?: any;\r\n    readonly memoryLength?: any;\r\n    readonly items: any;\r\n\r\n    constructor(items: any, memoryStart?: any, memoryLength?: any) {\r\n        this.name = 'RETURN';\r\n        this.wrapped = true;\r\n        if (memoryStart && memoryLength) {\r\n            this.memoryStart = memoryStart;\r\n            this.memoryLength = memoryLength;\r\n        } else {\r\n            this.items = items;\r\n        }\r\n    }\r\n\r\n    toString() {\r\n        if (this.memoryStart && this.memoryLength) {\r\n            return (\r\n                'return memory[' +\r\n                stringify(this.memoryStart) +\r\n                ':(' +\r\n                stringify(this.memoryStart) +\r\n                '+' +\r\n                stringify(this.memoryLength) +\r\n                ')];'\r\n            );\r\n        } else if (this.items.length === 0) {\r\n            return 'return;';\r\n        } else if (\r\n            this.items.length === 1 &&\r\n            (BigNumber.isInstance(this.items[0]) || this.items[0].static)\r\n        ) {\r\n            return 'return ' + this.items[0] + ';';\r\n        } else if (\r\n            this.items.length === 3 &&\r\n            this.items.every((item: any) => BigNumber.isInstance(item)) &&\r\n            this.items[0].equals(32)\r\n        ) {\r\n            return 'return \"' + hex2a(this.items[2].toString(16)) + '\";';\r\n        } else {\r\n            return 'return(' + this.items.map((item: any) => stringify(item)).join(', ') + ');';\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    state.halted = true;\r\n    if (BigNumber.isInstance(memoryStart) && BigNumber.isInstance(memoryLength)) {\r\n        const items = [];\r\n        for (\r\n            let i = memoryStart.toJSNumber();\r\n            i < memoryStart.add(memoryLength).toJSNumber();\r\n            i += 32\r\n        ) {\r\n            if (i in state.memory) {\r\n                items.push(state.memory[i]);\r\n            } else {\r\n                items.push(new MLOAD(i));\r\n            }\r\n        }\r\n        state.instructions.push(new RETURN(items));\r\n    } else {\r\n        state.instructions.push(new RETURN([], memoryStart, memoryLength));\r\n    }\r\n};\r\n","export function hex2a(hexx: any) {\n    const hex = hexx.toString();\n    let str = '';\n    for (let i = 0; i < hex.length && hex.substr(i, 2) !== '00'; i += 2) {\n        str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));\n    }\n    return str;\n}\n\nexport function pad32(data: string) {\n    if (data.length >= 64) {\n        return data;\n    } else {\n        return '0'.repeat(64 - data.length) + data;\n    }\n}\n\nexport function isHex(h: any) {\n    return /^[0-9a-f-]+$/.test(h);\n}\n\nexport default (data: any) => {\n    if (isHex(data)) {\n        const pieces = data.match(/.{1,64}/g);\n        if (pieces.length === 3 && parseInt(pieces[0], 16) === 32) {\n            const stringLength = parseInt(pieces[1], 16) * 2;\n            const stringData = hex2a(pieces[2].substr(0, stringLength));\n            return '\"' + stringData + '\"';\n        } else if (!isNaN(parseInt(data, 16))) {\n            return parseInt(data, 16).toString();\n        } else {\n            return data;\n        }\n    } else {\n        return data;\n    }\n};\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class DELEGATECALL {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly gas: any;\r\n    readonly address: any;\r\n    readonly memoryStart: any;\r\n    readonly memoryLength: any;\r\n    readonly outputStart: any;\r\n    readonly outputLength: any;\r\n\r\n    constructor(\r\n        gas: any,\r\n        address: any,\r\n        memoryStart: any,\r\n        memoryLength: any,\r\n        outputStart: any,\r\n        outputLength: any\r\n    ) {\r\n        this.name = 'DELEGATECALL';\r\n        this.wrapped = true;\r\n        this.gas = gas;\r\n        this.address = address;\r\n        this.memoryStart = memoryStart;\r\n        this.memoryLength = memoryLength;\r\n        this.outputStart = outputStart;\r\n        this.outputLength = outputLength;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            'delegatecall(' +\r\n            stringify(this.gas) +\r\n            ',' +\r\n            stringify(this.address) +\r\n            ',' +\r\n            stringify(this.memoryStart) +\r\n            ',' +\r\n            stringify(this.memoryLength) +\r\n            ',' +\r\n            stringify(this.outputStart) +\r\n            ',' +\r\n            stringify(this.outputLength) +\r\n            ')'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const gas = state.stack.pop();\r\n    const address = state.stack.pop();\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    const outputStart = state.stack.pop();\r\n    const outputLength = state.stack.pop();\r\n    state.stack.push(\r\n        new DELEGATECALL(gas, address, memoryStart, memoryLength, outputStart, outputLength)\r\n    );\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class CREATE2 {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly memoryStart: any;\r\n    readonly memoryLength: any;\r\n    readonly value: any;\r\n\r\n    constructor(memoryStart: any, memoryLength: any, value: any) {\r\n        this.name = 'CREATE2';\r\n        this.wrapped = true;\r\n        this.memoryStart = memoryStart;\r\n        this.memoryLength = memoryLength;\r\n        this.value = value;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            '(new Contract(memory[' +\r\n            stringify(this.memoryStart) +\r\n            ':(' +\r\n            stringify(this.memoryStart) +\r\n            '+' +\r\n            stringify(this.memoryLength) +\r\n            ')]).value(' +\r\n            stringify(this.value) +\r\n            ')).address'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const value = state.stack.pop();\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    state.stack.push(new CREATE2(memoryStart, memoryLength, value));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class STATICCALL {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly gas: any;\r\n    readonly address: any;\r\n    readonly memoryStart: any;\r\n    readonly memoryLength: any;\r\n    readonly outputStart: any;\r\n    readonly outputLength: any;\r\n\r\n    constructor(\r\n        gas: any,\r\n        address: any,\r\n        memoryStart: any,\r\n        memoryLength: any,\r\n        outputStart: any,\r\n        outputLength: any\r\n    ) {\r\n        this.name = 'STATICCALL';\r\n        this.wrapped = true;\r\n        this.gas = gas;\r\n        this.address = address;\r\n        this.memoryStart = memoryStart;\r\n        this.memoryLength = memoryLength;\r\n        this.outputStart = outputStart;\r\n        this.outputLength = outputLength;\r\n    }\r\n\r\n    toString() {\r\n        return (\r\n            'staticcall(' +\r\n            stringify(this.gas) +\r\n            ',' +\r\n            stringify(this.address) +\r\n            ',' +\r\n            stringify(this.memoryStart) +\r\n            ',' +\r\n            stringify(this.memoryLength) +\r\n            ',' +\r\n            stringify(this.outputStart) +\r\n            ',' +\r\n            stringify(this.outputLength) +\r\n            ')'\r\n        );\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const gas = state.stack.pop();\r\n    const address = state.stack.pop();\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    const outputStart = state.stack.pop();\r\n    const outputLength = state.stack.pop();\r\n    state.stack.push(\r\n        new STATICCALL(gas, address, memoryStart, memoryLength, outputStart, outputLength)\r\n    );\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport { MLOAD } from './mload';\r\nimport * as BigNumber from '../../node_modules/big-integer';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class REVERT {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly memoryStart?: any;\r\n    readonly memoryLength?: any;\r\n    readonly items: any;\r\n\r\n    constructor(items: any, memoryStart?: any, memoryLength?: any) {\r\n        this.name = 'REVERT';\r\n        this.wrapped = true;\r\n        if (memoryStart && memoryLength) {\r\n            this.memoryStart = memoryStart;\r\n            this.memoryLength = memoryLength;\r\n        } else {\r\n            this.items = items;\r\n        }\r\n    }\r\n\r\n    toString() {\r\n        if (this.items) {\r\n            return 'revert(' + this.items.map((item: any) => stringify(item)).join(', ') + ');';\r\n        } else {\r\n            return (\r\n                'revert(memory[' +\r\n                stringify(this.memoryStart) +\r\n                ':(' +\r\n                stringify(this.memoryStart) +\r\n                '+' +\r\n                stringify(this.memoryLength) +\r\n                ')]);'\r\n            );\r\n        }\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const memoryStart = state.stack.pop();\r\n    const memoryLength = state.stack.pop();\r\n    state.halted = true;\r\n    if (BigNumber.isInstance(memoryStart) && BigNumber.isInstance(memoryLength)) {\r\n        const items = [];\r\n        for (\r\n            let i = memoryStart.toJSNumber();\r\n            i < memoryStart.add(memoryLength).toJSNumber();\r\n            i += 32\r\n        ) {\r\n            if (i in state.memory) {\r\n                items.push(state.memory[i]);\r\n            } else {\r\n                items.push(new MLOAD(i));\r\n            }\r\n        }\r\n        state.instructions.push(new REVERT(items));\r\n    } else {\r\n        state.instructions.push(new REVERT([], memoryStart, memoryLength));\r\n    }\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\n\r\nexport class INVALID {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly opcode: any;\r\n\r\n    constructor(opcode: any) {\r\n        this.name = 'INVALID';\r\n        this.wrapped = true;\r\n        this.opcode = opcode;\r\n    }\r\n\r\n    toString() {\r\n        return 'revert(\"Invalid instruction (0x' + this.opcode.toString(16) + ')\");';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    state.halted = true;\r\n    state.instructions.push(new INVALID(opcode.opcode));\r\n};\r\n","import EVM from '../classes/evm.class';\r\nimport Opcode from '../interfaces/opcode.interface';\r\nimport stringify from '../utils/stringify';\r\n\r\nexport class SELFDESTRUCT {\r\n    readonly name: string;\r\n    readonly type?: string;\r\n    readonly wrapped: boolean;\r\n    readonly address: any;\r\n\r\n    constructor(address: any) {\r\n        this.name = 'SELFDESTRUCT';\r\n        this.wrapped = true;\r\n        this.address = address;\r\n    }\r\n\r\n    toString() {\r\n        return 'selfdestruct(' + stringify(this.address) + ');';\r\n    }\r\n}\r\n\r\nexport default (opcode: Opcode, state: EVM): void => {\r\n    const address = state.stack.pop();\r\n    state.halted = true;\r\n    state.instructions.push(new SELFDESTRUCT(address));\r\n};\r\n","export default (stateEvents: any, events: string[]) => {\r\n    const stateEventValues = Object.keys(stateEvents).map((key: string) => stateEvents[key]);\r\n    let output = '';\r\n\r\n    events.forEach((event: string) => {\r\n        const eventName = event.split('(')[0];\r\n        const eventArguments = event\r\n            .replace(eventName, '')\r\n            .substring(1)\r\n            .slice(0, -1);\r\n        output += 'event ';\r\n        if (eventArguments) {\r\n            output += eventName + '(';\r\n            output += eventArguments\r\n                .split(',')\r\n                .map((a: string, i: number) => {\r\n                    const stateEvent = stateEventValues.find((e: any) => e.label === event);\r\n                    if (stateEvent && i < stateEvent.indexedCount) {\r\n                        return a + ' indexed _arg' + i;\r\n                    } else {\r\n                        return a + ' _arg' + i;\r\n                    }\r\n                })\r\n                .join(', ');\r\n            output += ')';\r\n        } else {\r\n            output += event;\r\n        }\r\n        output += '\\n';\r\n    });\r\n\r\n    if (events.length > 0) {\r\n        output += '\\n';\r\n    }\r\n\r\n    return output;\r\n};\r\n","export default (mappings: any) => {\r\n    let output = '';\r\n\r\n    Object.keys(mappings)\r\n        .filter((key: any) => mappings[key].structs.length > 0)\r\n        .forEach((key: string, index: number) => {\r\n            const mapping = mappings[key];\r\n            output += 'struct ' + mapping.name + 'Struct {\\n';\r\n            mapping.structs.forEach((struct: any) => {\r\n                output += '    ' + struct.toString() + ';\\n';\r\n            });\r\n            output += '}\\n\\n';\r\n        });\r\n\r\n    return output;\r\n};\r\n","const stringifyMapping = (mapping: any) => {\r\n    const mappingKey: string[] = [];\r\n    const mappingValue: string[] = [];\r\n    let deepMapping = false;\r\n    mapping.keys\r\n        .filter((mappingChild: any) => mappingChild.length > 0)\r\n        .forEach((mappingChild: any) => {\r\n            if (\r\n                mappingChild.length > 0 &&\r\n                mappingChild[0].type &&\r\n                !mappingKey.includes(mappingChild[0].type)\r\n            ) {\r\n                mappingKey.push(mappingChild[0].type);\r\n            }\r\n            if (mappingChild.length > 1 && !deepMapping) {\r\n                deepMapping = true;\r\n                mappingValue.push(\r\n                    stringifyMapping({\r\n                        name: mapping.name,\r\n                        structs: mapping.structs,\r\n                        keys: mapping.keys.map((items: any) => {\r\n                            items.shift();\r\n                            return items;\r\n                        }),\r\n                        values: mapping.values\r\n                    })\r\n                );\r\n            } else if (mappingChild.length === 1 && !deepMapping) {\r\n                mapping.values.forEach((mappingChild2: any) => {\r\n                    if (mappingChild2.type && !mappingValue.includes(mappingChild2.type)) {\r\n                        mappingValue.push(mappingChild2.type);\r\n                    }\r\n                });\r\n            }\r\n        });\r\n    if (mappingKey.length === 0) {\r\n        mappingKey.push('unknown');\r\n    }\r\n    if (mapping.structs.length > 0 && mappingValue.length === 0) {\r\n        mappingValue.push(mapping.name + 'Struct');\r\n    } else if (mappingValue.length === 0) {\r\n        mappingValue.push('unknown');\r\n    }\r\n    return 'mapping (' + mappingKey.join('|') + ' => ' + mappingValue.join('|') + ')';\r\n};\r\n\r\nexport default (mappings: any) => {\r\n    let output = '';\r\n\r\n    Object.keys(mappings).forEach((key: string, index: number) => {\r\n        const mapping = mappings[key];\r\n        if (mapping.name) {\r\n            output += stringifyMapping(mapping) + ' public ' + mapping.name + ';';\r\n        } else {\r\n            output += stringifyMapping(mapping) + ' mapping' + (index + 1) + ';';\r\n        }\r\n        output += '\\n';\r\n    });\r\n\r\n    if (Object.keys(mappings).length > 0) {\r\n        output += '\\n';\r\n    }\r\n\r\n    return output;\r\n};\r\n","export default (variables: any) => {\r\n    let output = '';\r\n\r\n    Object.keys(variables).forEach((key: string, index: number) => {\r\n        const variable = variables[key];\r\n        const types = variable.types\r\n            .map((type: any) => {\r\n                if (typeof type === 'function') {\r\n                    return type();\r\n                } else {\r\n                    return type;\r\n                }\r\n            })\r\n            .filter((type: any) => type);\r\n        if (types.length === 0) {\r\n            types.push('unknown');\r\n        }\r\n        if (variable.label) {\r\n            output += [...new Set(types)].join('|') + ' public ' + variable.label + ';';\r\n        } else {\r\n            output += [...new Set(types)].join('|') + ' var' + (index + 1).toString() + ';';\r\n            index++;\r\n        }\r\n        output += '\\n';\r\n    });\r\n\r\n    if (Object.keys(variables).length > 0) {\r\n        output += '\\n';\r\n    }\r\n\r\n    return output;\r\n};\r\n","import stringifyInstructions from './stringifyInstructions';\r\nimport * as functionHashes from '../../data/functionHashes.json';\r\n\r\nexport default (functionName: string, functionInstance: any): string => {\r\n    let output = '';\r\n    output += 'function ';\r\n    if (functionName in functionHashes) {\r\n        const fullFunction = (functionHashes as any)[functionName];\r\n        const fullFunctionName = fullFunction.split('(')[0];\r\n        const fullFunctionArguments = fullFunction\r\n            .replace(fullFunctionName, '')\r\n            .substring(1)\r\n            .slice(0, -1);\r\n        if (fullFunctionArguments) {\r\n            output += fullFunctionName + '(';\r\n            output += fullFunctionArguments\r\n                .split(',')\r\n                .map((a: string, i: number) => a + ' _arg' + i)\r\n                .join(', ');\r\n            output += ')';\r\n        } else {\r\n            output += fullFunction;\r\n        }\r\n    } else {\r\n        output += functionName + '()';\r\n    }\r\n    output += ' ' + functionInstance.visibility;\r\n    if (functionInstance.constant) {\r\n        output += ' view';\r\n    }\r\n    if (functionInstance.payable) {\r\n        output += ' payable';\r\n    }\r\n    if (functionInstance.returns.length > 0) {\r\n        output += ' returns (' + functionInstance.returns.join(', ') + ')';\r\n    }\r\n    output += ' {\\n';\r\n    output += stringifyInstructions(functionInstance.items, 4);\r\n    output += '}\\n\\n';\r\n    return output;\r\n};\r\n","export default class Stack {\r\n    elements: any[];\r\n\r\n    constructor() {\r\n        this.elements = [];\r\n    }\r\n\r\n    push(item: any): void {\r\n        if (this.elements.length >= 1024) {\r\n            throw new Error('Stack too deep');\r\n        } else {\r\n            this.elements.unshift(item);\r\n        }\r\n    }\r\n\r\n    pop(): any {\r\n        if (this.elements.length === 0) {\r\n            throw new Error('POP with empty stack');\r\n        } else {\r\n            return this.elements.shift();\r\n        }\r\n    }\r\n\r\n    duplicate(position: number): void {\r\n        if (position < 0 || position > 15) {\r\n            throw new Error('Unsupported position for duplication operation');\r\n        } else if (!(position in this.elements)) {\r\n            throw new Error(\r\n                \"Invalid duplication operation, provided position wasn't found in stack\"\r\n            );\r\n        } else {\r\n            this.push(this.elements[position]);\r\n        }\r\n    }\r\n\r\n    swap(secondPosition: number): void {\r\n        if (secondPosition < 1 || secondPosition > 16) {\r\n            throw new Error('Unsupported position for swap operation');\r\n        } else if (!(secondPosition in this.elements)) {\r\n            throw new Error(\"Invalid swap operation, provided position wasn't found in stack\");\r\n        } else {\r\n            const firstValue = this.elements[0];\r\n            const secondValue = this.elements[secondPosition];\r\n            this.elements[0] = secondValue;\r\n            this.elements[secondPosition] = firstValue;\r\n        }\r\n    }\r\n\r\n    clone(): Stack {\r\n        const stack = new Stack();\r\n        stack.elements = [...this.elements];\r\n        return stack;\r\n    }\r\n\r\n    reset(): void {\r\n        this.elements = [];\r\n    }\r\n}\r\n"],"sourceRoot":""}