{"version":3,"sources":["webpack:///./node_modules/@ethersproject/sha2/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/sha2/lib.esm/sha2.js","webpack:///./node_modules/@ethersproject/strings/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/strings/lib.esm/utf8.js","webpack:///./node_modules/@ethersproject/strings/lib.esm/bytes32.js","webpack:///./node_modules/@ethersproject/strings/lib.esm/idna.js","webpack:///./node_modules/@ethersproject/signing-key/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/signing-key/lib.esm/index.js","webpack:///./node_modules/@ethersproject/signing-key/lib.esm/elliptic.js","webpack:///./node_modules/@ethersproject/sha2/lib.esm/types.js","webpack:///./node_modules/@ethersproject/solidity/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/solidity/lib.esm/index.js"],"names":["logger","ripemd160","data","update","digest","sha256","sha512","computeHmac","algorithm","key","throwError","errors","UNSUPPORTED_OPERATION","operation","hmac","UnicodeNormalizationForm","Utf8ErrorReason","ignoreFunc","reason","offset","bytes","output","badCodepoint","BAD_PREFIX","UNEXPECTED_CONTINUE","i","o","length","OVERRUN","Utf8ErrorFuncs","Object","freeze","error","throwArgumentError","ignore","replace","OVERLONG","push","getUtf8CodePoints","onError","result","c","extraLength","overlongMask","res","j","nextChar","MISSING_CONTINUE","OUT_OF_RANGE","UTF16_SURROGATE","toUtf8Bytes","str","form","current","checkNormalize","normalize","charCodeAt","c2","Error","pair","escapeChar","value","hex","toString","substring","_toEscapedUtf8String","map","codePoint","String","fromCharCode","join","_toUtf8String","codePoints","toUtf8String","toUtf8CodePoints","formatBytes32String","text","slice","parseBytes32String","createTable","func","parseInt","lo","split","forEach","comps","createRangeTable","hi","v","l","h","matchMap","ranges","range","d","e","indexOf","Table_A_1_ranges","Table_B_1_flags","Table_B_2_ranges","s","Table_B_2_lut_abs","Table_B_2_lut_rel","Table_B_2_complex","Table_C_ranges","nameprep","match","toLowerCase","codes","values","reduce","accum","flatten","code","codesTableB2","codepoint","shift","_nameprepTableB2","NFKC","_nameprepTableC","_nameprepTableA1","name","_curve","getCurve","constructor","privateKey","this","keyPair","keyFromPrivate","getPublic","_addPoint","other","p0","keyFromPublic","publicKey","p1","pub","add","encodeCompressed","signDigest","digestBytes","signature","sign","canonical","recoveryParam","r","computeSharedSecret","otherKey","otherKeyPair","computePublicKey","derive","static","_isSigningKey","recoverPublicKey","sig","rs","recoverPubKey","encode","compressed","signingKey","createCommonjsModule","fn","basedir","module","path","exports","require","base","commonjsRequire","globalThis","window","global","self","minimalisticAssert","assert","val","msg","equal","utils_1","utils","zero2","word","toHex","toArray","enc","Array","isArray","arr","utils_1$1","getNAF","num","w","bits","naf","Math","max","bitLength","fill","ws","k","clone","z","mod","andln","isOdd","isubn","iushrn","getJSF","k1","k2","jsf","m8","d1","d2","cmpn","u1","u2","m14","m24","cachedProperty","obj","computer","prototype","call","parseBytes","intFromLE","assert$1","BaseCurve","type","conf","p","red","prime","mont","zero","toRed","one","two","n","g","pointFromJSON","gRed","_wnafT1","_wnafT2","_wnafT3","_wnafT4","_bitLength","adjustCount","div","redN","_maxwellTrick","BasePoint","curve","precomputed","point","validate","_fixedNafMul","doubles","_getDoubles","I","step","nafW","repr","a","jpoint","b","mixedAdd","points","neg","toP","_wnafMul","nafPoints","_getNAFPoints","wnd","acc","dblp","_wnafMulAdd","defW","coeffs","len","jacobianResult","wndWidth","comb","y","cmp","toJ","redNeg","index","ja","jb","tmp","eq","decodePoint","byteLength","pointFromX","_encode","compact","x","getX","getY","isEven","concat","precompute","power","beta","_getBeta","_hasDoubles","ceil","dbl","inherits_browser","create","ctor","superCtor","super_","enumerable","writable","configurable","TempCtor","assert$2","ShortCurve","tinv","redInvm","zeroA","fromRed","threeA","sub","endo","_getEndomorphism","_endoWnafT1","_endoWnafT2","short_1","Point","isRed","inf","forceRed","JPoint","zOne","modn","lambda","betas","_getEndoRoots","lambdas","mul","redMul","basis","vec","_getEndoBasis","ntinv","redSqrt","redAdd","redSub","a0","b0","a1","b1","a2","b2","prevR","aprxSqrt","ushrn","floor","u","x1","y1","x2","y2","q","len1","sqr","negative","_endoSplit","v1","v2","c1","divRound","p2","q1","q2","odd","redSqr","redIAdd","ax","rhs","redISub","_endoWnafMulAdd","npoints","ncoeffs","ineg","fromJSON","pre","endoMul","toJSON","JSON","parse","obj2point","inspect","isInfinity","nx","ny","ys1","dyinv","mulAdd","jmulAdd","_precompute","negate","zinv","zinv2","ay","pz2","z2","s1","s2","h2","h3","nz","pow","jx","jy","jz","jz4","jyd","jx2","jyd2","jyd4","t1","t2","dny","_zeroDbl","_threeDbl","_dbl","xx","yy","yyyy","m","t","yyyy8","f","c8","delta","gamma","alpha","beta4","beta8","ggamma8","jy2","jxd4","jyd8","trpl","zz","mm","ee","yyu4","kbase","z3","pz3","eqXToP","zs","rx","xc","iadd","curve_1","short","edwards","curves_1","curves","PresetCurve","options","hash","defineCurve","defineProperty","get","sha384","crash","HmacDRBG","predResist","outLen","outSize","minEntropy","hmacStrength","_reseed","reseedInterval","K","V","entropy","entropyEnc","nonce","nonceEnc","pers","persEnc","_init","hmacDrbg","seed","_update","_hmac","kmac","reseed","addEnc","generate","temp","assert$3","KeyPair","ec","priv","_importPrivate","privEnc","_importPublic","pubEnc","fromPublic","fromPrivate","getPrivate","umod","verify","assert$4","Signature","_importDER","Position","place","getLength","buf","initial","octetLen","off","rmPadding","constructLength","octets","log","LN2","rlen","slen","toDER","backHalf","rand","assert$5","EC","hasOwnProperty","nh","genKeyPair","drbg","ns2","iaddn","_truncateToN","truncOnly","bkey","ns1","iter","kp","kpX","invm","signature$1","sinv","isYOdd","isSecondKey","rInv","getKeyRecoveryParam","Q","Qprime","elliptic_1","elliptic","version","eddsa","EC$1","SupportedAlgorithm","regexBytes","RegExp","regexNumber","regexArray","_pack","size","from","toTwos","baseType","pack","types","tight","keccak256"],"mappings":"uTAAO,MCODA,EAAS,IAAI,IDPI,cCQhB,SAASC,EAAUC,GACtB,MAAO,KAAQ,IAAKD,YAAYE,OAAO,YAASD,IAAOE,OAAO,OAE3D,SAASC,EAAOH,GACnB,MAAO,KAAQ,IAAKG,SAASF,OAAO,YAASD,IAAOE,OAAO,OAExD,SAASE,EAAOJ,GACnB,MAAO,KAAQ,IAAKI,SAASH,OAAO,YAASD,IAAOE,OAAO,OAExD,SAASG,EAAYC,EAAWC,EAAKP,GAOxC,OANK,IAAmBM,IACpBR,EAAOU,WAAW,yBAA2BF,EAAW,IAAOG,OAAOC,sBAAuB,CACzFC,UAAW,OACXL,UAAWA,IAGZ,KAAO,IAAKM,KAAK,IAAKN,GAAY,YAASC,IAAMN,OAAO,YAASD,IAAOE,OAAO,S,kUCxBnF,MCIDJ,EAAS,I,UAAI,GDJI,iBCMhB,IAAIe,EASAC,EA+BX,SAASC,EAAWC,EAAQC,EAAQC,EAAOC,EAAQC,GAE/C,GAAIJ,IAAWF,EAAgBO,YAAcL,IAAWF,EAAgBQ,oBAAqB,CACzF,IAAIC,EAAI,EACR,IAAK,IAAIC,EAAIP,EAAS,EAAGO,EAAIN,EAAMO,QAC3BP,EAAMM,IAAM,GAAM,EADiBA,IAIvCD,IAEJ,OAAOA,EAIX,OAAIP,IAAWF,EAAgBY,QACpBR,EAAMO,OAASR,EAAS,EAG5B,GAW0CG,SApE1CP,GACPA,EAAkC,QAAI,GACtCA,EAA8B,IAAI,MAClCA,EAA8B,IAAI,MAClCA,EAA+B,KAAI,OACnCA,EAA+B,KAAI,QA+DcO,CA9DlDP,IAA6BA,EAA2B,KAG3D,SAAWC,GAGPA,EAAqC,oBAAI,+BAGzCA,EAA4B,WAAI,uBAGhCA,EAAyB,QAAI,iBAG7BA,EAAkC,iBAAI,4BAItCA,EAA8B,aAAI,qBAIlCA,EAAiC,gBAAI,mBAIrCA,EAA0B,SAAI,0BAxBlC,CAyBGA,IAAoBA,EAAkB,KAqClC,MAAMa,EAAiBC,OAAOC,OAAO,CACxCC,MApCJ,SAAmBd,EAAQC,EAAQC,EAAOC,EAAQC,GAC9C,OAAOtB,EAAOiC,mBAAmB,+BAA+Bd,MAAWD,IAAU,QAASE,IAoC9Fc,OAAQjB,EACRkB,QAfJ,SAAqBjB,EAAQC,EAAQC,EAAOC,EAAQC,GAEhD,OAAIJ,IAAWF,EAAgBoB,UAC3Bf,EAAOgB,KAAKf,GACL,IAGXD,EAAOgB,KAAK,OAELpB,EAAWC,EAAQC,EAAQC,OAStC,SAASkB,EAAkBlB,EAAOmB,GACf,MAAXA,IACAA,EAAUV,EAAeG,OAE7BZ,EAAQ,YAASA,GACjB,MAAMoB,EAAS,GACf,IAAIf,EAAI,EAER,KAAOA,EAAIL,EAAMO,QAAQ,CACrB,MAAMc,EAAIrB,EAAMK,KAEhB,GAAIgB,GAAK,GAAM,EAAG,CACdD,EAAOH,KAAKI,GACZ,SAGJ,IAAIC,EAAc,KACdC,EAAe,KAEnB,GAAmB,MAAV,IAAJF,GACDC,EAAc,EACdC,EAAe,SAGd,GAAmB,MAAV,IAAJF,GACNC,EAAc,EACdC,EAAe,SAGd,IAAmB,MAAV,IAAJF,GAIL,CAEGhB,GAAKc,EADU,MAAV,IAAJE,GACYzB,EAAgBQ,oBAGhBR,EAAgBO,WAHqBE,EAAI,EAAGL,EAAOoB,GAKpE,SAVAE,EAAc,EACdC,EAAe,MAYnB,GAAIlB,EAAI,EAAIiB,GAAetB,EAAMO,OAAQ,CACrCF,GAAKc,EAAQvB,EAAgBY,QAASH,EAAI,EAAGL,EAAOoB,GACpD,SAGJ,IAAII,EAAMH,GAAM,GAAM,EAAIC,EAAc,GAAM,EAC9C,IAAK,IAAIG,EAAI,EAAGA,EAAIH,EAAaG,IAAK,CAClC,IAAIC,EAAW1B,EAAMK,GAErB,GAAyB,MAAT,IAAXqB,GAA0B,CAC3BrB,GAAKc,EAAQvB,EAAgB+B,iBAAkBtB,EAAGL,EAAOoB,GACzDI,EAAM,KACN,MAGJA,EAAOA,GAAO,EAAiB,GAAXE,EACpBrB,IAGQ,OAARmB,IAIAA,EAAM,QACNnB,GAAKc,EAAQvB,EAAgBgC,aAAcvB,EAAI,EAAIiB,EAAatB,EAAOoB,EAAQI,GAI/EA,GAAO,OAAUA,GAAO,MACxBnB,GAAKc,EAAQvB,EAAgBiC,gBAAiBxB,EAAI,EAAIiB,EAAatB,EAAOoB,EAAQI,GAIlFA,GAAOD,EACPlB,GAAKc,EAAQvB,EAAgBoB,SAAUX,EAAI,EAAIiB,EAAatB,EAAOoB,EAAQI,GAG/EJ,EAAOH,KAAKO,IAEhB,OAAOJ,EAGJ,SAASU,EAAYC,EAAKC,EAAOrC,EAAyBsC,SACzDD,GAAQrC,EAAyBsC,UACjCrD,EAAOsD,iBACPH,EAAMA,EAAII,UAAUH,IAExB,IAAIZ,EAAS,GACb,IAAK,IAAIf,EAAI,EAAGA,EAAI0B,EAAIxB,OAAQF,IAAK,CACjC,MAAMgB,EAAIU,EAAIK,WAAW/B,GACzB,GAAIgB,EAAI,IACJD,EAAOH,KAAKI,QAEX,GAAIA,EAAI,KACTD,EAAOH,KAAMI,GAAK,EAAK,KACvBD,EAAOH,KAAU,GAAJI,EAAY,UAExB,GAAoB,QAAX,MAAJA,GAAuB,CAC7BhB,IACA,MAAMgC,EAAKN,EAAIK,WAAW/B,GAC1B,GAAIA,GAAK0B,EAAIxB,QAA4B,QAAZ,MAAL8B,GACpB,MAAM,IAAIC,MAAM,wBAGpB,MAAMC,EAAO,QAAgB,KAAJlB,IAAe,KAAY,KAALgB,GAC/CjB,EAAOH,KAAMsB,GAAQ,GAAM,KAC3BnB,EAAOH,KAAOsB,GAAQ,GAAM,GAAQ,KACpCnB,EAAOH,KAAOsB,GAAQ,EAAK,GAAQ,KACnCnB,EAAOH,KAAa,GAAPsB,EAAe,UAG5BnB,EAAOH,KAAMI,GAAK,GAAM,KACxBD,EAAOH,KAAOI,GAAK,EAAK,GAAQ,KAChCD,EAAOH,KAAU,GAAJI,EAAY,KAGjC,OAAO,YAASD,GAGpB,SAASoB,EAAWC,GAChB,MAAMC,EAAO,OAASD,EAAME,SAAS,IACrC,MAAO,MAAQD,EAAIE,UAAUF,EAAInC,OAAS,GAEvC,SAASsC,EAAqB7C,EAAOmB,GACxC,MAAO,IAAMD,EAAkBlB,EAAOmB,GAAS2B,KAAKC,IAChD,GAAIA,EAAY,IAAK,CACjB,OAAQA,GACJ,KAAK,EAAG,MAAO,MACf,KAAK,EAAG,MAAO,MACf,KAAK,GAAI,MAAO,MAChB,KAAK,GAAI,MAAO,MAChB,KAAK,GAAI,MAAO,MAChB,KAAK,GAAI,MAAO,OAEpB,GAAIA,GAAa,IAAMA,EAAY,IAC/B,OAAOC,OAAOC,aAAaF,GAGnC,OAAIA,GAAa,MACNP,EAAWO,GAGfP,EAAyC,QADhDO,GAAa,QACoB,GAAM,OAAmBP,EAAiC,OAAT,KAAZO,OACvEG,KAAK,IAAM,IAEX,SAASC,EAAcC,GAC1B,OAAOA,EAAWN,KAAKC,GACfA,GAAa,MACNC,OAAOC,aAAaF,IAE/BA,GAAa,MACNC,OAAOC,aAA4C,OAA5BF,GAAa,GAAM,MAAyC,OAAT,KAAZA,OACtEG,KAAK,IAEL,SAASG,EAAarD,EAAOmB,GAChC,OAAOgC,EAAcjC,EAAkBlB,EAAOmB,IAE3C,SAASmC,EAAiBvB,EAAKC,EAAOrC,EAAyBsC,SAClE,OAAOf,EAAkBY,EAAYC,EAAKC,M,oCCrP9C,4GAIO,SAASuB,EAAoBC,GAEhC,MAAMxD,EAAQ,YAAYwD,GAE1B,GAAIxD,EAAMO,OAAS,GACf,MAAM,IAAI+B,MAAM,6CAGpB,OAAO,YAAQ,YAAO,CAACtC,EAAO,MAAWyD,MAAM,EAAG,KAE/C,SAASC,EAAmB1D,GAC/B,MAAMlB,EAAO,YAASkB,GAEtB,GAAoB,KAAhBlB,EAAKyB,OACL,MAAM,IAAI+B,MAAM,uCAEpB,GAAiB,IAAbxD,EAAK,IACL,MAAM,IAAIwD,MAAM,+CAGpB,IAAI/B,EAAS,GACb,KAA4B,IAArBzB,EAAKyB,EAAS,IACjBA,IAGJ,OAAO,YAAazB,EAAK2E,MAAM,EAAGlD,M,kCC7BtC,kDAYA,SAASoD,EAAY7E,EAAM8E,GAClBA,IACDA,EAAO,SAAUnB,GAAS,MAAO,CAACoB,SAASpB,EAAO,OAEtD,IAAIqB,EAAK,EACL1C,EAAS,GAMb,OALAtC,EAAKiF,MAAM,KAAKC,SAASzB,IACrB,IAAI0B,EAAQ1B,EAAKwB,MAAM,KACvBD,GAAMD,SAASI,EAAM,GAAI,IACzB7C,EAAO0C,GAAMF,EAAKK,EAAM,OAErB7C,EAEX,SAAS8C,EAAiBpF,GACtB,IAAIqF,EAAK,EACT,OAAOrF,EAAKiF,MAAM,KAAKjB,KAAKsB,IACxB,IAAIH,EAAQG,EAAEL,MAAM,KACC,IAAjBE,EAAM1D,OACN0D,EAAM,GAAK,IAEO,KAAbA,EAAM,KACXA,EAAM,GAAK,KAEf,IAAIH,EAAKK,EAAKN,SAASI,EAAM,GAAI,IAEjC,OADAE,EAAKN,SAASI,EAAM,GAAI,IACjB,CAAEI,EAAGP,EAAIQ,EAAGH,MAG3B,SAASI,EAAS9B,EAAO+B,GACrB,IAAIV,EAAK,EACT,IAAK,IAAIzD,EAAI,EAAGA,EAAImE,EAAOjE,OAAQF,IAAK,CACpC,IAAIoE,EAAQD,EAAOnE,GAEnB,GADAyD,GAAMW,EAAMJ,EACR5B,GAASqB,GAAMrB,GAASqB,EAAKW,EAAMH,IAAO7B,EAAQqB,IAAOW,EAAMC,GAAK,IAAQ,EAAG,CAC/E,GAAID,EAAME,IAAsC,IAAjCF,EAAME,EAAEC,QAAQnC,EAAQqB,GACnC,SAEJ,OAAOW,GAGf,OAAO,KAEX,MAAMI,EAAmBX,EAAiB,g8CAEpCY,EAAkB,sDAAsDf,MAAM,KAAKjB,KAAKsB,GAAMP,SAASO,EAAG,MAC1GW,EAAmB,CACrB,CAAET,EAAG,GAAIU,EAAG,GAAIX,EAAG,IACnB,CAAEC,EAAG,GAAIU,EAAG,GAAIL,EAAG,CAAC,IAAKN,EAAG,KAC5B,CAAEC,EAAG,GAAIU,EAAG,EAAGL,EAAG,CAAC,IAAKN,EAAG,GAAIK,EAAG,GAClC,CAAEJ,EAAG,GAAIU,EAAG,EAAGX,EAAG,GAAIK,EAAG,GACzB,CAAEJ,EAAG,GAAIU,EAAG,EAAGX,EAAG,GAAIK,EAAG,GACzB,CAAEJ,EAAG,GAAIU,EAAG,EAAGL,EAAG,CAAC,EAAG,EAAG,GAAIN,EAAG,GAAIK,EAAG,GACvC,CAAEJ,EAAG,GAAIU,EAAG,EAAGX,EAAG,GAAIK,EAAG,GACzB,CAAEJ,EAAG,GAAIU,EAAG,EAAGL,EAAG,CAAC,GAAI,GAAI,IAAKN,EAAG,GAAIK,EAAG,GAC1C,CAAEJ,EAAG,GAAIU,EAAG,GAAIL,EAAG,CAAC,IAAKN,EAAG,KAC5B,CAAEC,EAAG,GAAIU,EAAG,EAAGX,EAAG,GAAIK,EAAG,GACzB,CAAEJ,EAAG,GAAIU,EAAG,GAAIX,EAAG,IACnB,CAAEC,EAAG,GAAIU,EAAG,GAAIX,EAAG,IACnB,CAAEC,EAAG,GAAIU,EAAG,EAAGX,EAAG,GAAIK,EAAG,GACzB,CAAEJ,EAAG,GAAIU,EAAG,EAAGX,EAAG,GAAIK,EAAG,GACzB,CAAEJ,EAAG,GAAIU,EAAG,EAAGX,EAAG,GAAIK,EAAG,GACzB,CAAEJ,EAAG,GAAIU,EAAG,EAAGL,EAAG,CAAC,IAAKN,EAAG,GAAIK,EAAG,GAClC,CAAEJ,EAAG,GAAIU,EAAG,EAAGX,EAAG,GAAIK,EAAG,GACzB,CAAEJ,EAAG,GAAIU,EAAG,GAAIX,EAAG,IACnB,CAAEC,EAAG,IAAKU,EAAG,EAAGX,EAAG,KAAMK,EAAG,GAC5B,CAAEJ,EAAG,GAAIU,EAAG,EAAGX,EAAG,IAAKK,EAAG,GAC1B,CAAEJ,EAAG,GAAIU,EAAG,GAAIX,EAAG,KACnB,CAAEC,EAAG,GAAIU,EAAG,GAAIX,EAAG,KACnB,CAAEC,EAAG,GAAIU,EAAG,GAAIX,EAAG,OACnB,CAAEC,EAAG,GAAIU,EAAG,GAAIX,EAAG,MACnB,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,OACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQL,EAAG,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,IAAKN,EAAG,IACxD,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQL,EAAG,CAAC,EAAG,EAAG,EAAG,IAAKN,EAAG,IAC1C,CAAEC,EAAG,GAAIU,GAAI,OAAQL,EAAG,CAAC,EAAG,EAAG,GAAI,GAAI,GAAI,IAAKN,EAAG,IACnD,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQX,EAAG,IACxB,CAAEC,EAAG,GAAIU,GAAI,OAAQL,EAAG,CAAC,IAAKN,EAAG,IACjC,CAAEC,EAAG,GAAIU,GAAI,OAAQL,EAAG,CAAC,IAAKN,EAAG,IACjC,CAAEC,EAAG,GAAIU,GAAI,OAAQL,EAAG,CAAC,IAAKN,EAAG,IACjC,CAAEC,EAAG,GAAIU,GAAI,OAAQL,EAAG,CAAC,IAAKN,EAAG,IACjC,CAAEC,EAAG,GAAIU,GAAI,OAAQL,EAAG,CAAC,IAAKN,EAAG,KAE/BY,EAAoBtB,EAAY,yfAChCuB,EAAoBvB,EAAY,0dAChCwB,EAAoBxB,EAAY,03DArGtC,SAAgB7E,GACZ,GAAKA,EAAKyB,OAAS,GAAO,EACtB,MAAM,IAAI+B,MAAM,YAEpB,IAAIlB,EAAS,GACb,IAAK,IAAIf,EAAI,EAAGA,EAAIvB,EAAKyB,OAAQF,GAAK,EAClCe,EAAOH,KAAK4C,SAAS/E,EAAK8D,UAAUvC,EAAGA,EAAI,GAAI,KAEnD,OAAOe,KA8FLgE,EAAiBlB,EAAiB,2LAgCjC,SAASmB,EAAS5C,GAIrB,GAAIA,EAAM6C,MAAM,kBAAoB7C,EAAMlC,QAAU,GAChD,OAAOkC,EAAM8C,cAGjB,IAAIC,EAAQ,YAAiB/C,GAC7B+C,EAxCJ,SAAiBC,GACb,OAAOA,EAAOC,QAAO,CAACC,EAAOlD,KACzBA,EAAMuB,SAASvB,IAAYkD,EAAM1E,KAAKwB,MAC/BkD,IACR,IAoCKC,CAAQJ,EAAM1C,KAAK+C,IAEvB,GAAIf,EAAgBF,QAAQiB,IAAS,EACjC,MAAO,GAEX,GAAIA,GAAQ,OAAUA,GAAQ,MAC1B,MAAO,GAGX,IAAIC,EAxCL,SAA0BC,GAC7B,IAAItB,EAAQF,EAASwB,EAAWhB,GAChC,GAAIN,EACA,MAAO,CAACsB,EAAYtB,EAAMO,GAE9B,IAAIQ,EAAQP,EAAkBc,GAC9B,GAAIP,EACA,OAAOA,EAEX,IAAIQ,EAAQd,EAAkBa,GAC9B,OAAIC,EACO,CAACD,EAAYC,EAAM,IAEhBb,EAAkBY,IAIzB,KAuBgBE,CAAiBJ,GACpC,OAAIC,GAIG,CAACD,OAGZL,EAAQ,YAAiB,YAAcA,GAAQ,IAAyBU,MAExEV,EAAMxB,SAAS6B,IACX,GAhCD,SAAyBE,GAC5B,QAASxB,EAASwB,EAAWX,GA+BrBe,CAAgBN,GAChB,MAAM,IAAIvD,MAAM,qCAIxBkD,EAAMxB,SAAS6B,IACX,GA5DD,SAA0BE,GAC7B,QAASxB,EAASwB,EAAWlB,GA2DrBuB,CAAiBP,GACjB,MAAM,IAAIvD,MAAM,qCAIxB,IAAI+D,EAAO,YAAcb,GAEzB,GAA6B,MAAzBa,EAAKzD,UAAU,EAAG,IAAuC,OAAzByD,EAAKzD,UAAU,EAAG,IAAmD,MAApCyD,EAAKzD,UAAUyD,EAAK9F,OAAS,GAC9F,MAAM,IAAI+B,MAAM,kBAGpB,GAAI+D,EAAK9F,OAAS,GACd,MAAM,IAAI+B,MAAM,YAEpB,OAAO+D,I,gLCzLJ,MCMDzH,EAAS,I,UAAI,GDNI,qBCOvB,IAAI0H,EAAS,KACb,SAASC,IAIL,OAHKD,IACDA,EAAS,IAAI,IAAG,cAEbA,EAEJ,MAAM,EACTE,YAAYC,GACR,YAAeC,KAAM,QAAS,aAC9B,YAAeA,KAAM,aAAc,YAAQD,IAC3C,MAAME,EAAUJ,IAAWK,eAAe,YAASF,KAAKD,aACxD,YAAeC,KAAM,YAAa,KAAOC,EAAQE,WAAUA,EAAO,QAClE,YAAeH,KAAM,sBAAuB,KAAOC,EAAQE,WAAUA,EAAM,QAC3E,YAAeH,KAAM,iBAAgB,GAEzCI,UAAUC,GACN,MAAMC,EAAKT,IAAWU,cAAc,YAASP,KAAKQ,YAC5CC,EAAKZ,IAAWU,cAAc,YAASF,IAC7C,MAAO,KAAOC,EAAGI,IAAIC,IAAIF,EAAGC,KAAKE,iBAAiB,OAEtDC,WAAWvI,GACP,MAAM2H,EAAUJ,IAAWK,eAAe,YAASF,KAAKD,aAClDe,EAAc,YAASxI,GACF,KAAvBwI,EAAYjH,QACZ3B,EAAOiC,mBAAmB,oBAAqB,SAAU7B,GAE7D,MAAMyI,EAAYd,EAAQe,KAAKF,EAAa,CAAEG,WAAUA,IACxD,OAAO,YAAe,CAClBC,cAAeH,EAAUG,cACzBC,EAAG,YAAW,KAAOJ,EAAUI,EAAElF,SAAS,IAAK,IAC/CqC,EAAG,YAAW,KAAOyC,EAAUzC,EAAErC,SAAS,IAAK,MAGvDmF,oBAAoBC,GAChB,MAAMpB,EAAUJ,IAAWK,eAAe,YAASF,KAAKD,aAClDuB,EAAezB,IAAWU,cAAc,YAASgB,EAAiBF,KACxE,OAAO,YAAW,KAAOpB,EAAQuB,OAAOF,EAAanB,aAAalE,SAAS,IAAK,IAEpFwF,oBAAoB1F,GAChB,SAAUA,IAASA,EAAM2F,gBAG1B,SAASC,EAAiBrJ,EAAQyI,GACrC,MAAMa,EAAM,YAAeb,GACrBc,EAAK,CAAEV,EAAG,YAASS,EAAIT,GAAI7C,EAAG,YAASsD,EAAItD,IACjD,MAAO,KAAOuB,IAAWiC,cAAc,YAASxJ,GAASuJ,EAAID,EAAIV,eAAea,OAAO,OAAM,GAE1F,SAASR,EAAiB5I,EAAKqJ,GAClC,MAAM1I,EAAQ,YAASX,GACvB,GAAqB,KAAjBW,EAAMO,OAAe,CACrB,MAAMoI,EAAa,IAAI,EAAW3I,GAClC,OAAI0I,EACO,KAAOnC,IAAWK,eAAe5G,GAAO6G,WAAUA,EAAM,OAE5D8B,EAAWzB,UAEjB,OAAqB,KAAjBlH,EAAMO,OACPmI,EACO,YAAQ1I,GAEZ,KAAOuG,IAAWU,cAAcjH,GAAO6G,WAAUA,EAAO,OAEzC,KAAjB7G,EAAMO,OACNmI,EAGE,KAAOnC,IAAWU,cAAcjH,GAAO6G,WAAUA,EAAM,OAFnD,YAAQ7G,GAIhBpB,EAAOiC,mBAAmB,gCAAiC,MAAO,gB,4CC5E7E,8DAAAR,EAAA,gBAAAA,GASA,SAASuI,EAAqBC,EAAIC,EAASC,GAC1C,OAAOA,EAAS,CACfC,KAAMF,EACNG,QAAS,GACTC,QAAS,SAAUF,EAAMG,GACxB,OA4BH,WACC,MAAM,IAAI7G,MAAM,2EA7BP8G,CAAgBJ,MAAOG,GAAuCJ,EAAOC,QAE3EH,EAAGE,EAAQA,EAAOE,SAAUF,EAAOE,QAbI,oBAAfI,WAA6BA,WAA+B,oBAAXC,OAAyBA,YAA2B,IAAXC,GAAkD,oBAATC,MAAuBA,KA2CtL,IAAIC,EAAqBC,EAEzB,SAASA,EAAOC,EAAKC,GACnB,IAAKD,EACH,MAAM,IAAIrH,MAAMsH,GAAO,oBAG3BF,EAAOG,MAAQ,SAAqBxF,EAAGwD,EAAG+B,GACxC,GAAIvF,GAAKwD,EACP,MAAM,IAAIvF,MAAMsH,GAAQ,qBAAuBvF,EAAI,OAASwD,IAGhE,IAAIiC,EAAUlB,YAA+BG,EAAQE,GAGrD,IAAIc,EAAQd,EAkCZ,SAASe,EAAMC,GACb,OAAoB,IAAhBA,EAAK1J,OACA,IAAM0J,EAENA,EAIX,SAASC,EAAMN,GAEb,IADA,IAAIpI,EAAM,GACDnB,EAAI,EAAGA,EAAIuJ,EAAIrJ,OAAQF,IAC9BmB,GAAOwI,EAAMJ,EAAIvJ,GAAGsC,SAAS,KAC/B,OAAOnB,EAdTuI,EAAMI,QA9BN,SAAiBP,EAAKQ,GACpB,GAAIC,MAAMC,QAAQV,GAChB,OAAOA,EAAInG,QACb,IAAKmG,EACH,MAAO,GACT,IAAIpI,EAAM,GACV,GAAmB,iBAARoI,EAAkB,CAC3B,IAAK,IAAIvJ,EAAI,EAAGA,EAAIuJ,EAAIrJ,OAAQF,IAC9BmB,EAAInB,GAAc,EAATuJ,EAAIvJ,GACf,OAAOmB,EAET,GAAY,QAAR4I,EAIF,KAHAR,EAAMA,EAAI7I,QAAQ,eAAgB,KAC1BR,OAAS,GAAM,IACrBqJ,EAAM,IAAMA,GACLvJ,EAAI,EAAGA,EAAIuJ,EAAIrJ,OAAQF,GAAK,EACnCmB,EAAIP,KAAK4C,SAAS+F,EAAIvJ,GAAKuJ,EAAIvJ,EAAI,GAAI,UAEzC,IAASA,EAAI,EAAGA,EAAIuJ,EAAIrJ,OAAQF,IAAK,CACnC,IAAIgB,EAAIuI,EAAIxH,WAAW/B,GACnB8D,EAAK9C,GAAK,EACVyC,EAAS,IAAJzC,EACL8C,EACF3C,EAAIP,KAAKkD,EAAIL,GAEbtC,EAAIP,KAAK6C,GAGf,OAAOtC,GAUTuI,EAAMC,MAAQA,EAQdD,EAAMG,MAAQA,EAEdH,EAAMtB,OAAS,SAAgB8B,EAAKH,GAClC,MAAY,QAARA,EACKF,EAAMK,GAENA,MAIPC,EAAY5B,YAA+BG,EAAQE,GAGvD,IAAIc,EAAQd,EAKZc,EAAML,OAASD,EACfM,EAAMI,QAAUL,EAAQK,QACxBJ,EAAMC,MAAQF,EAAQE,MACtBD,EAAMG,MAAQJ,EAAQI,MACtBH,EAAMtB,OAASqB,EAAQrB,OA6BvBsB,EAAMU,OA1BN,SAAgBC,EAAKC,EAAGC,GACtB,IAAIC,EAAM,IAAIR,MAAMS,KAAKC,IAAIL,EAAIM,YAAaJ,GAAQ,GACtDC,EAAII,KAAK,GAKT,IAHA,IAAIC,EAAK,GAAMP,EAAI,EACfQ,EAAIT,EAAIU,QAEH/K,EAAI,EAAGA,EAAIwK,EAAItK,OAAQF,IAAK,CACnC,IAAIgL,EACAC,EAAMH,EAAEI,MAAML,EAAK,GACnBC,EAAEK,SAEFH,EADEC,GAAOJ,GAAM,GAAK,GACfA,GAAM,GAAKI,EAEZA,EACNH,EAAEM,MAAMJ,IAERA,EAAI,EAGNR,EAAIxK,GAAKgL,EACTF,EAAEO,OAAO,GAGX,OAAOb,GA2DTd,EAAM4B,OAtDN,SAAgBC,EAAIC,GAClB,IAAIC,EAAM,CACR,GACA,IAGFF,EAAKA,EAAGR,QACRS,EAAKA,EAAGT,QAIR,IAHA,IAEIW,EAFAC,EAAK,EACLC,EAAK,EAEFL,EAAGM,MAAMF,GAAM,GAAKH,EAAGK,MAAMD,GAAM,GAAG,CAE3C,IAMIE,EAYAC,EAlBAC,EAAOT,EAAGL,MAAM,GAAKS,EAAM,EAC3BM,EAAOT,EAAGN,MAAM,GAAKU,EAAM,EACnB,IAARI,IACFA,GAAO,GACG,IAARC,IACFA,GAAO,GAES,IAAP,EAAND,GACHF,EAAK,EAMHA,EAHU,KADZJ,EAAMH,EAAGL,MAAM,GAAKS,EAAM,IACF,IAAPD,GAAqB,IAARO,EAGvBD,GAFCA,EAIVP,EAAI,GAAG7K,KAAKkL,GAGM,IAAP,EAANG,GACHF,EAAK,EAMHA,EAHU,KADZL,EAAMF,EAAGN,MAAM,GAAKU,EAAM,IACF,IAAPF,GAAqB,IAARM,EAGvBC,GAFCA,EAIVR,EAAI,GAAG7K,KAAKmL,GAGR,EAAIJ,IAAOG,EAAK,IAClBH,EAAK,EAAIA,GACP,EAAIC,IAAOG,EAAK,IAClBH,EAAK,EAAIA,GACXL,EAAGF,OAAO,GACVG,EAAGH,OAAO,GAGZ,OAAOI,GAWT/B,EAAMwC,eAPN,SAAwBC,EAAKnG,EAAMoG,GACjC,IAAIpN,EAAM,IAAMgH,EAChBmG,EAAIE,UAAUrG,GAAQ,WACpB,YAAO,IAAAK,KAAKrH,GAAqBqH,KAAKrH,GACpCqH,KAAKrH,GAAOoN,EAASE,KAAKjG,QAShCqD,EAAM6C,WAJN,SAAoB5M,GAClB,MAAwB,iBAAVA,EAAqB+J,EAAMI,QAAQnK,EAAO,OACtDA,GAOJ+J,EAAM8C,UAHN,SAAmB7M,GACjB,OAAO,IAAI,IAAGA,EAAO,MAAO,UAS1ByK,EAASD,EAAUC,OACnBkB,EAASnB,EAAUmB,OACnBmB,EAAWtC,EAAUd,OAEzB,SAASqD,EAAUC,EAAMC,GACvBvG,KAAKsG,KAAOA,EACZtG,KAAKwG,EAAI,IAAI,IAAGD,EAAKC,EAAG,IAGxBxG,KAAKyG,IAAMF,EAAKG,MAAQ,IAAGD,IAAIF,EAAKG,OAAS,IAAGC,KAAK3G,KAAKwG,GAG1DxG,KAAK4G,KAAO,IAAI,IAAG,GAAGC,MAAM7G,KAAKyG,KACjCzG,KAAK8G,IAAM,IAAI,IAAG,GAAGD,MAAM7G,KAAKyG,KAChCzG,KAAK+G,IAAM,IAAI,IAAG,GAAGF,MAAM7G,KAAKyG,KAGhCzG,KAAKgH,EAAIT,EAAKS,GAAK,IAAI,IAAGT,EAAKS,EAAG,IAClChH,KAAKiH,EAAIV,EAAKU,GAAKjH,KAAKkH,cAAcX,EAAKU,EAAGV,EAAKY,MAGnDnH,KAAKoH,QAAU,IAAIzD,MAAM,GACzB3D,KAAKqH,QAAU,IAAI1D,MAAM,GACzB3D,KAAKsH,QAAU,IAAI3D,MAAM,GACzB3D,KAAKuH,QAAU,IAAI5D,MAAM,GAEzB3D,KAAKwH,WAAaxH,KAAKgH,EAAIhH,KAAKgH,EAAE1C,YAAc,EAGhD,IAAImD,EAAczH,KAAKgH,GAAKhH,KAAKwG,EAAEkB,IAAI1H,KAAKgH,IACvCS,GAAeA,EAAYjC,KAAK,KAAO,EAC1CxF,KAAK2H,KAAO,MAEZ3H,KAAK4H,iBACL5H,KAAK2H,KAAO3H,KAAKgH,EAAEH,MAAM7G,KAAKyG,MAGlC,IAAIhE,EAAO4D,EAqNX,SAASwB,EAAUC,EAAOxB,GACxBtG,KAAK8H,MAAQA,EACb9H,KAAKsG,KAAOA,EACZtG,KAAK+H,YAAc,KAtNrB1B,EAAUL,UAAUgC,MAAQ,WAC1B,MAAM,IAAIpM,MAAM,oBAGlByK,EAAUL,UAAUiC,SAAW,WAC7B,MAAM,IAAIrM,MAAM,oBAGlByK,EAAUL,UAAUkC,aAAe,SAAsB1B,EAAG/B,GAC1D2B,EAASI,EAAEuB,aACX,IAAII,EAAU3B,EAAE4B,cAEZjE,EAAMJ,EAAOU,EAAG,EAAGzE,KAAKwH,YACxBa,GAAK,GAAMF,EAAQG,KAAO,IAAOH,EAAQG,KAAO,GAAM,EAAI,EAAI,GAClED,GAAK,EAGL,IACItN,EACAwN,EAFAC,EAAO,GAGX,IAAKzN,EAAI,EAAGA,EAAIoJ,EAAItK,OAAQkB,GAAKoN,EAAQG,KAAM,CAC7CC,EAAO,EACP,IAAK,IAAI5K,EAAI5C,EAAIoN,EAAQG,KAAO,EAAG3K,GAAK5C,EAAG4C,IACzC4K,GAAQA,GAAQ,GAAKpE,EAAIxG,GAC3B6K,EAAKjO,KAAKgO,GAKZ,IAFA,IAAIE,EAAIzI,KAAK0I,OAAO,KAAM,KAAM,MAC5BC,EAAI3I,KAAK0I,OAAO,KAAM,KAAM,MACvB/O,EAAI0O,EAAG1O,EAAI,EAAGA,IAAK,CAC1B,IAAKoB,EAAI,EAAGA,EAAIyN,EAAK3O,OAAQkB,KAC3BwN,EAAOC,EAAKzN,MACCpB,EACXgP,EAAIA,EAAEC,SAAST,EAAQU,OAAO9N,IACvBwN,KAAU5O,IACjBgP,EAAIA,EAAEC,SAAST,EAAQU,OAAO9N,GAAG+N,QAErCL,EAAIA,EAAE9H,IAAIgI,GAEZ,OAAOF,EAAEM,OAGX1C,EAAUL,UAAUgD,SAAW,SAAkBxC,EAAG/B,GAClD,IAAIR,EAAI,EAGJgF,EAAYzC,EAAE0C,cAAcjF,GAChCA,EAAIgF,EAAUE,IAQd,IAPA,IAAIA,EAAMF,EAAUJ,OAGhB1E,EAAMJ,EAAOU,EAAGR,EAAGjE,KAAKwH,YAGxB4B,EAAMpJ,KAAK0I,OAAO,KAAM,KAAM,MACzB/O,EAAIwK,EAAItK,OAAS,EAAGF,GAAK,EAAGA,IAAK,CAExC,IAAK,IAAIgE,EAAI,EAAGhE,GAAK,GAAgB,IAAXwK,EAAIxK,GAAUA,IACtCgE,IAKF,GAJIhE,GAAK,GACPgE,IACFyL,EAAMA,EAAIC,KAAK1L,GAEXhE,EAAI,EACN,MACF,IAAIgL,EAAIR,EAAIxK,GACZyM,EAAe,IAANzB,GAILyE,EAHW,WAAX5C,EAAEF,KAEA3B,EAAI,EACAyE,EAAIR,SAASO,EAAKxE,EAAI,GAAM,IAE5ByE,EAAIR,SAASO,GAAMxE,EAAI,GAAM,GAAGmE,OAGpCnE,EAAI,EACAyE,EAAIzI,IAAIwI,EAAKxE,EAAI,GAAM,IAEvByE,EAAIzI,IAAIwI,GAAMxE,EAAI,GAAM,GAAGmE,OAGvC,MAAkB,WAAXtC,EAAEF,KAAoB8C,EAAIL,MAAQK,GAG3C/C,EAAUL,UAAUsD,YAAc,SAAqBC,EACrDV,EACAW,EACAC,EACAC,GACA,IAMI/P,EACAoB,EACAyL,EARAmD,EAAW3J,KAAKoH,QAChB+B,EAAMnJ,KAAKqH,QACXlD,EAAMnE,KAAKsH,QAGXjD,EAAM,EAIV,IAAK1K,EAAI,EAAGA,EAAI8P,EAAK9P,IAAK,CAExB,IAAIsP,GADJzC,EAAIqC,EAAOlP,IACOuP,cAAcK,GAChCI,EAAShQ,GAAKsP,EAAUE,IACxBA,EAAIxP,GAAKsP,EAAUJ,OAIrB,IAAKlP,EAAI8P,EAAM,EAAG9P,GAAK,EAAGA,GAAK,EAAG,CAChC,IAAI8O,EAAI9O,EAAI,EACRgP,EAAIhP,EACR,GAAoB,IAAhBgQ,EAASlB,IAA4B,IAAhBkB,EAAShB,GAAlC,CAQA,IAAIiB,EAAO,CACTf,EAAOJ,GACP,KACA,KACAI,EAAOF,IAI4B,IAAjCE,EAAOJ,GAAGoB,EAAEC,IAAIjB,EAAOF,GAAGkB,IAC5BD,EAAK,GAAKf,EAAOJ,GAAG9H,IAAIkI,EAAOF,IAC/BiB,EAAK,GAAKf,EAAOJ,GAAGsB,MAAMnB,SAASC,EAAOF,GAAGG,QACM,IAA1CD,EAAOJ,GAAGoB,EAAEC,IAAIjB,EAAOF,GAAGkB,EAAEG,WACrCJ,EAAK,GAAKf,EAAOJ,GAAGsB,MAAMnB,SAASC,EAAOF,IAC1CiB,EAAK,GAAKf,EAAOJ,GAAG9H,IAAIkI,EAAOF,GAAGG,SAElCc,EAAK,GAAKf,EAAOJ,GAAGsB,MAAMnB,SAASC,EAAOF,IAC1CiB,EAAK,GAAKf,EAAOJ,GAAGsB,MAAMnB,SAASC,EAAOF,GAAGG,QAG/C,IAAImB,EAAQ,EACT,GACA,GACA,GACA,EACD,EACA,EACA,EACA,EACA,GAGE7E,EAAMH,EAAOuE,EAAOf,GAAIe,EAAOb,IAInC,IAHAtE,EAAMD,KAAKC,IAAIe,EAAI,GAAGvL,OAAQwK,GAC9BF,EAAIsE,GAAK,IAAI9E,MAAMU,GACnBF,EAAIwE,GAAK,IAAIhF,MAAMU,GACdtJ,EAAI,EAAGA,EAAIsJ,EAAKtJ,IAAK,CACxB,IAAImP,EAAiB,EAAZ9E,EAAI,GAAGrK,GACZoP,EAAiB,EAAZ/E,EAAI,GAAGrK,GAEhBoJ,EAAIsE,GAAG1N,GAAKkP,EAAiB,GAAVC,EAAK,IAAUC,EAAK,IACvChG,EAAIwE,GAAG5N,GAAK,EACZoO,EAAIV,GAAKmB,QAhDTzF,EAAIsE,GAAK1E,EAAOyF,EAAOf,GAAIkB,EAASlB,GAAIzI,KAAKwH,YAC7CrD,EAAIwE,GAAK5E,EAAOyF,EAAOb,GAAIgB,EAAShB,GAAI3I,KAAKwH,YAC7CnD,EAAMD,KAAKC,IAAIF,EAAIsE,GAAG5O,OAAQwK,GAC9BA,EAAMD,KAAKC,IAAIF,EAAIwE,GAAG9O,OAAQwK,GAiDlC,IAAI+E,EAAMpJ,KAAK0I,OAAO,KAAM,KAAM,MAC9B0B,EAAMpK,KAAKuH,QACf,IAAK5N,EAAI0K,EAAK1K,GAAK,EAAGA,IAAK,CAGzB,IAFA,IAAI8K,EAAI,EAED9K,GAAK,GAAG,CACb,IAAIiN,KACJ,IAAK7L,EAAI,EAAGA,EAAI0O,EAAK1O,IACnBqP,EAAIrP,GAAiB,EAAZoJ,EAAIpJ,GAAGpB,GACD,IAAXyQ,EAAIrP,KACN6L,MAEJ,IAAKA,EACH,MACFnC,IACA9K,IAKF,GAHIA,GAAK,GACP8K,IACF2E,EAAMA,EAAIC,KAAK5E,GACX9K,EAAI,EACN,MAEF,IAAKoB,EAAI,EAAGA,EAAI0O,EAAK1O,IAAK,CACxB,IAAI4J,EAAIyF,EAAIrP,GAEF,IAAN4J,IAEKA,EAAI,EACX6B,EAAI2C,EAAIpO,GAAI4J,EAAI,GAAM,GACfA,EAAI,IACX6B,EAAI2C,EAAIpO,IAAK4J,EAAI,GAAM,GAAGmE,OAG1BM,EADa,WAAX5C,EAAEF,KACE8C,EAAIR,SAASpC,GAEb4C,EAAIzI,IAAI6F,KAIpB,IAAK7M,EAAI,EAAGA,EAAI8P,EAAK9P,IACnBwP,EAAIxP,GAAK,KAEX,OAAI+P,EACKN,EAEAA,EAAIL,OAQf1C,EAAUwB,UAAYA,EAEtBA,EAAU7B,UAAUqE,GAAK,WACvB,MAAM,IAAIzO,MAAM,oBAGlBiM,EAAU7B,UAAUiC,SAAW,WAC7B,OAAOjI,KAAK8H,MAAMG,SAASjI,OAG7BqG,EAAUL,UAAUsE,YAAc,SAAqBhR,EAAOoK,GAC5DpK,EAAQwK,EAAUL,QAAQnK,EAAOoK,GAEjC,IAAI+F,EAAMzJ,KAAKwG,EAAE+D,aAGjB,IAAkB,IAAbjR,EAAM,IAA4B,IAAbA,EAAM,IAA4B,IAAbA,EAAM,KACjDA,EAAMO,OAAS,GAAM,EAAI4P,EAS3B,OARiB,IAAbnQ,EAAM,GACR8M,EAAS9M,EAAMA,EAAMO,OAAS,GAAK,GAAM,GACrB,IAAbP,EAAM,IACb8M,EAAS9M,EAAMA,EAAMO,OAAS,GAAK,GAAM,GAEhCmG,KAAKgI,MAAM1O,EAAMyD,MAAM,EAAG,EAAI0M,GACvCnQ,EAAMyD,MAAM,EAAI0M,EAAK,EAAI,EAAIA,IAG1B,IAAkB,IAAbnQ,EAAM,IAA4B,IAAbA,EAAM,KAC3BA,EAAMO,OAAS,IAAM4P,EAC/B,OAAOzJ,KAAKwK,WAAWlR,EAAMyD,MAAM,EAAG,EAAI0M,GAAmB,IAAbnQ,EAAM,IAExD,MAAM,IAAIsC,MAAM,yBAGlBiM,EAAU7B,UAAUpF,iBAAmB,SAA0B8C,GAC/D,OAAO1D,KAAK+B,OAAO2B,OAGrBmE,EAAU7B,UAAUyE,QAAU,SAAiBC,GAC7C,IAAIjB,EAAMzJ,KAAK8H,MAAMtB,EAAE+D,aACnBI,EAAI3K,KAAK4K,OAAOnH,QAAQ,KAAMgG,GAElC,OAAIiB,EACK,CAAE1K,KAAK6K,OAAOC,SAAW,EAAO,GAAOC,OAAOJ,GAEhD,CAAE,GAAOI,OAAOJ,EAAG3K,KAAK6K,OAAOpH,QAAQ,KAAMgG,KAGtD5B,EAAU7B,UAAUjE,OAAS,SAAgB2B,EAAKgH,GAChD,OAAO5G,EAAU/B,OAAO/B,KAAKyK,QAAQC,GAAUhH,IAGjDmE,EAAU7B,UAAUgF,WAAa,SAAoBC,GACnD,GAAIjL,KAAK+H,YACP,OAAO/H,KAET,IAAI+H,EAAc,CAChBI,QAAS,KACThE,IAAK,KACL+G,KAAM,MAOR,OALAnD,EAAY5D,IAAMnE,KAAKkJ,cAAc,GACrCnB,EAAYI,QAAUnI,KAAKoI,YAAY,EAAG6C,GAC1ClD,EAAYmD,KAAOlL,KAAKmL,WACxBnL,KAAK+H,YAAcA,EAEZ/H,MAGT6H,EAAU7B,UAAUoF,YAAc,SAAqB3G,GACrD,IAAKzE,KAAK+H,YACR,OAAM,EAER,IAAII,EAAUnI,KAAK+H,YAAYI,QAC/B,QAAKA,GAGEA,EAAQU,OAAOhP,QAAUuK,KAAKiH,MAAM5G,EAAEH,YAAc,GAAK6D,EAAQG,OAG1ET,EAAU7B,UAAUoC,YAAc,SAAqBE,EAAM2C,GAC3D,GAAIjL,KAAK+H,aAAe/H,KAAK+H,YAAYI,QACvC,OAAOnI,KAAK+H,YAAYI,QAI1B,IAFA,IAAIA,EAAU,CAAEnI,MACZoJ,EAAMpJ,KACDrG,EAAI,EAAGA,EAAIsR,EAAOtR,GAAK2O,EAAM,CACpC,IAAK,IAAIvN,EAAI,EAAGA,EAAIuN,EAAMvN,IACxBqO,EAAMA,EAAIkC,MACZnD,EAAQ5N,KAAK6O,GAEf,MAAO,CACLd,KAAMA,EACNO,OAAQV,IAIZN,EAAU7B,UAAUkD,cAAgB,SAAuBC,GACzD,GAAInJ,KAAK+H,aAAe/H,KAAK+H,YAAY5D,IACvC,OAAOnE,KAAK+H,YAAY5D,IAK1B,IAHA,IAAIrJ,EAAM,CAAEkF,MACRqE,GAAO,GAAK8E,GAAO,EACnBmC,EAAc,IAARjH,EAAY,KAAOrE,KAAKsL,MACzB3R,EAAI,EAAGA,EAAI0K,EAAK1K,IACvBmB,EAAInB,GAAKmB,EAAInB,EAAI,GAAGgH,IAAI2K,GAC1B,MAAO,CACLnC,IAAKA,EACLN,OAAQ/N,IAIZ+M,EAAU7B,UAAUmF,SAAW,WAC7B,OAAO,MAGTtD,EAAU7B,UAAUqD,KAAO,SAAc5E,GAEvC,IADA,IAAItD,EAAInB,KACCrG,EAAI,EAAGA,EAAI8K,EAAG9K,IACrBwH,EAAIA,EAAEmK,MACR,OAAOnK,GAGT,IAAIoK,EAAmBrJ,YAA+BG,GACzB,mBAAlBrI,OAAOwR,OAEhBnJ,EAAOE,QAAU,SAAkBkJ,EAAMC,GACnCA,IACFD,EAAKE,OAASD,EACdD,EAAKzF,UAAYhM,OAAOwR,OAAOE,EAAU1F,UAAW,CAClDlG,YAAa,CACX/D,MAAO0P,EACPG,YAAWA,EACXC,UAASA,EACTC,cAAaA,OAOrBzJ,EAAOE,QAAU,SAAkBkJ,EAAMC,GACvC,GAAIA,EAAW,CACbD,EAAKE,OAASD,EACd,IAAIK,EAAW,aACfA,EAAS/F,UAAY0F,EAAU1F,UAC/ByF,EAAKzF,UAAY,IAAI+F,EACrBN,EAAKzF,UAAUlG,YAAc2L,OAa/BO,EAAWlI,EAAUd,OAEzB,SAASiJ,EAAW1F,GAClB9D,EAAKwD,KAAKjG,KAAM,QAASuG,GAEzBvG,KAAKyI,EAAI,IAAI,IAAGlC,EAAKkC,EAAG,IAAI5B,MAAM7G,KAAKyG,KACvCzG,KAAK2I,EAAI,IAAI,IAAGpC,EAAKoC,EAAG,IAAI9B,MAAM7G,KAAKyG,KACvCzG,KAAKkM,KAAOlM,KAAK+G,IAAIoF,UAErBnM,KAAKoM,MAAqC,IAA7BpM,KAAKyI,EAAE4D,UAAU7G,KAAK,GACnCxF,KAAKsM,OAAmD,IAA1CtM,KAAKyI,EAAE4D,UAAUE,IAAIvM,KAAKwG,GAAGhB,MAAM,GAGjDxF,KAAKwM,KAAOxM,KAAKyM,iBAAiBlG,GAClCvG,KAAK0M,YAAc,IAAI/I,MAAM,GAC7B3D,KAAK2M,YAAc,IAAIhJ,MAAM,GAE/B4H,EAAiBU,EAAYxJ,GAC7B,IAAImK,EAAUX,EAiOd,SAASY,EAAM/E,EAAO6C,EAAGd,EAAGiD,GAC1BrK,EAAKoF,UAAU5B,KAAKjG,KAAM8H,EAAO,UACvB,OAAN6C,GAAoB,OAANd,GAChB7J,KAAK2K,EAAI,KACT3K,KAAK6J,EAAI,KACT7J,KAAK+M,SAEL/M,KAAK2K,EAAI,IAAI,IAAGA,EAAG,IACnB3K,KAAK6J,EAAI,IAAI,IAAGA,EAAG,IAEfiD,IACF9M,KAAK2K,EAAEqC,SAAShN,KAAK8H,MAAMrB,KAC3BzG,KAAK6J,EAAEmD,SAAShN,KAAK8H,MAAMrB,MAExBzG,KAAK2K,EAAElE,MACVzG,KAAK2K,EAAI3K,KAAK2K,EAAE9D,MAAM7G,KAAK8H,MAAMrB,MAC9BzG,KAAK6J,EAAEpD,MACVzG,KAAK6J,EAAI7J,KAAK6J,EAAEhD,MAAM7G,KAAK8H,MAAMrB,MACnCzG,KAAK+M,QA6NT,SAASE,EAAOnF,EAAO6C,EAAGd,EAAGlF,GAC3BlC,EAAKoF,UAAU5B,KAAKjG,KAAM8H,EAAO,YACvB,OAAN6C,GAAoB,OAANd,GAAoB,OAANlF,GAC9B3E,KAAK2K,EAAI3K,KAAK8H,MAAMhB,IACpB9G,KAAK6J,EAAI7J,KAAK8H,MAAMhB,IACpB9G,KAAK2E,EAAI,IAAI,IAAG,KAEhB3E,KAAK2K,EAAI,IAAI,IAAGA,EAAG,IACnB3K,KAAK6J,EAAI,IAAI,IAAGA,EAAG,IACnB7J,KAAK2E,EAAI,IAAI,IAAGA,EAAG,KAEhB3E,KAAK2K,EAAElE,MACVzG,KAAK2K,EAAI3K,KAAK2K,EAAE9D,MAAM7G,KAAK8H,MAAMrB,MAC9BzG,KAAK6J,EAAEpD,MACVzG,KAAK6J,EAAI7J,KAAK6J,EAAEhD,MAAM7G,KAAK8H,MAAMrB,MAC9BzG,KAAK2E,EAAE8B,MACVzG,KAAK2E,EAAI3E,KAAK2E,EAAEkC,MAAM7G,KAAK8H,MAAMrB,MAEnCzG,KAAKkN,KAAOlN,KAAK2E,IAAM3E,KAAK8H,MAAMhB,IAhepCmF,EAAWjG,UAAUyG,iBAAmB,SAA0BlG,GAEhE,GAAKvG,KAAKoM,OAAUpM,KAAKiH,GAAMjH,KAAKgH,GAAwB,IAAnBhH,KAAKwG,EAAE2G,KAAK,GAArD,CAIA,IAAIjC,EACAkC,EACJ,GAAI7G,EAAK2E,KACPA,EAAO,IAAI,IAAG3E,EAAK2E,KAAM,IAAIrE,MAAM7G,KAAKyG,SACnC,CACL,IAAI4G,EAAQrN,KAAKsN,cAActN,KAAKwG,GAGpC0E,GADAA,EAAOmC,EAAM,GAAGvD,IAAIuD,EAAM,IAAM,EAAIA,EAAM,GAAKA,EAAM,IACzCxG,MAAM7G,KAAKyG,KAEzB,GAAIF,EAAK6G,OACPA,EAAS,IAAI,IAAG7G,EAAK6G,OAAQ,QACxB,CAEL,IAAIG,EAAUvN,KAAKsN,cAActN,KAAKgH,GACsB,IAAxDhH,KAAKiH,EAAEuG,IAAID,EAAQ,IAAI5C,EAAEb,IAAI9J,KAAKiH,EAAE0D,EAAE8C,OAAOvC,IAC/CkC,EAASG,EAAQ,IAEjBH,EAASG,EAAQ,GACjBvB,EAA6D,IAApDhM,KAAKiH,EAAEuG,IAAIJ,GAAQzC,EAAEb,IAAI9J,KAAKiH,EAAE0D,EAAE8C,OAAOvC,MAiBtD,MAAO,CACLA,KAAMA,EACNkC,OAAQA,EACRM,MAdEnH,EAAKmH,MACCnH,EAAKmH,MAAMtR,KAAIA,SAASuR,GAC9B,MAAO,CACLlF,EAAG,IAAI,IAAGkF,EAAIlF,EAAG,IACjBE,EAAG,IAAI,IAAGgF,EAAIhF,EAAG,QAIb3I,KAAK4N,cAAcR,MAU/BnB,EAAWjG,UAAUsH,cAAgB,SAAuBtJ,GAI1D,IAAIyC,EAAMzC,IAAQhE,KAAKwG,EAAIxG,KAAKyG,IAAM,IAAGE,KAAK3C,GAC1CkI,EAAO,IAAI,IAAG,GAAGrF,MAAMJ,GAAK0F,UAC5B0B,EAAQ3B,EAAKlC,SAEb1L,EAAI,IAAI,IAAG,GAAGuI,MAAMJ,GAAKuD,SAAS8D,UAAUL,OAAOvB,GAIvD,MAAO,CAFE2B,EAAME,OAAOzP,GAAG+N,UAChBwB,EAAMG,OAAO1P,GAAG+N,YAI3BJ,EAAWjG,UAAU4H,cAAgB,SAAuBR,GA2B1D,IAzBA,IAYIa,EACAC,EAEAC,EACAC,EAEAC,EACAC,EAEAC,EAEApN,EACAwJ,EAxBA6D,EAAWxO,KAAKgH,EAAEyH,MAAMrK,KAAKsK,MAAM1O,KAAKgH,EAAE1C,YAAc,IAIxDqK,EAAIvB,EACJ1P,EAAIsC,KAAKgH,EAAEtC,QACXkK,EAAK,IAAI,IAAG,GACZC,EAAK,IAAI,IAAG,GACZC,EAAK,IAAI,IAAG,GACZC,EAAK,IAAI,IAAG,GAaZpV,EAAI,EAGa,IAAdgV,EAAEnJ,KAAK,IAAU,CACtB,IAAIwJ,EAAItR,EAAEgK,IAAIiH,GACdxN,EAAIzD,EAAE6O,IAAIyC,EAAExB,IAAImB,IAChBhE,EAAImE,EAAGvC,IAAIyC,EAAExB,IAAIoB,IACjB,IAAI/E,EAAIkF,EAAGxC,IAAIyC,EAAExB,IAAIqB,IAErB,IAAKV,GAAMhN,EAAE2I,IAAI0E,GAAY,EAC3BP,EAAKM,EAAMzF,MACXoF,EAAKU,EACLT,EAAKhN,EAAE2H,MACPsF,EAAKzD,OACA,GAAIwD,GAAc,KAANxU,EACjB,MAEF4U,EAAQpN,EAERzD,EAAIiR,EACJA,EAAIxN,EACJ2N,EAAKF,EACLA,EAAKjE,EACLoE,EAAKF,EACLA,EAAKhF,EAEPwE,EAAKlN,EAAE2H,MACPwF,EAAK3D,EAEL,IAAIsE,EAAOd,EAAGe,MAAMvO,IAAIyN,EAAGc,OAiB3B,OAhBWb,EAAGa,MAAMvO,IAAI2N,EAAGY,OAClBpF,IAAImF,IAAS,IACpBZ,EAAKJ,EACLK,EAAKJ,GAIHC,EAAGgB,WACLhB,EAAKA,EAAGrF,MACRsF,EAAKA,EAAGtF,OAENuF,EAAGc,WACLd,EAAKA,EAAGvF,MACRwF,EAAKA,EAAGxF,OAGH,CACL,CAAEL,EAAG0F,EAAIxF,EAAGyF,GACZ,CAAE3F,EAAG4F,EAAI1F,EAAG2F,KAIhBrC,EAAWjG,UAAUoJ,WAAa,SAAoB3K,GACpD,IAAIiJ,EAAQ1N,KAAKwM,KAAKkB,MAClB2B,EAAK3B,EAAM,GACX4B,EAAK5B,EAAM,GAEX6B,EAAKD,EAAG3G,EAAE6E,IAAI/I,GAAG+K,SAASxP,KAAKgH,GAC/BrL,EAAK0T,EAAG1G,EAAEG,MAAM0E,IAAI/I,GAAG+K,SAASxP,KAAKgH,GAErCvG,EAAK8O,EAAG/B,IAAI6B,EAAG5G,GACfgH,EAAK9T,EAAG6R,IAAI8B,EAAG7G,GACfiH,EAAKH,EAAG/B,IAAI6B,EAAG1G,GACfgH,EAAKhU,EAAG6R,IAAI8B,EAAG3G,GAKnB,MAAO,CAAEzD,GAFAT,EAAE8H,IAAI9L,GAAI8L,IAAIkD,GAENtK,GADRuK,EAAG/O,IAAIgP,GAAI7G,QAItBmD,EAAWjG,UAAUwE,WAAa,SAAoBG,EAAGiF,IACvDjF,EAAI,IAAI,IAAGA,EAAG,KACPlE,MACLkE,EAAIA,EAAE9D,MAAM7G,KAAKyG,MAEnB,IAAIsI,EAAKpE,EAAEkF,SAASpC,OAAO9C,GAAGmF,QAAQnF,EAAE8C,OAAOzN,KAAKyI,IAAIqH,QAAQ9P,KAAK2I,GACjEkB,EAAIkF,EAAGjB,UACX,GAA6C,IAAzCjE,EAAEgG,SAAS7B,OAAOe,GAAIjF,IAAI9J,KAAK4G,MACjC,MAAM,IAAIhL,MAAM,iBAIlB,IAAIkJ,EAAQ+E,EAAEwC,UAAUvH,QAIxB,OAHI8K,IAAQ9K,IAAU8K,GAAO9K,KAC3B+E,EAAIA,EAAEG,UAEDhK,KAAKgI,MAAM2C,EAAGd,IAGvBoC,EAAWjG,UAAUiC,SAAW,SAAkBD,GAChD,GAAIA,EAAM+E,IACR,OAAM,EAER,IAAIpC,EAAI3C,EAAM2C,EACVd,EAAI7B,EAAM6B,EAEVkG,EAAK/P,KAAKyI,EAAEgF,OAAO9C,GACnBqF,EAAMrF,EAAEkF,SAASpC,OAAO9C,GAAGmF,QAAQC,GAAID,QAAQ9P,KAAK2I,GACxD,OAA2C,IAApCkB,EAAEgG,SAASI,QAAQD,GAAKxK,KAAK,IAGtCyG,EAAWjG,UAAUkK,gBACjB,SAAyBrH,EAAQW,EAAQE,GAGvC,IAFA,IAAIyG,EAAUnQ,KAAK0M,YACf0D,EAAUpQ,KAAK2M,YACVhT,EAAI,EAAGA,EAAIkP,EAAOhP,OAAQF,IAAK,CACtC,IAAI0D,EAAQ2C,KAAKoP,WAAW5F,EAAO7P,IAC/B6M,EAAIqC,EAAOlP,GACXuR,EAAO1E,EAAE2E,WAET9N,EAAM6H,GAAGiK,WACX9R,EAAM6H,GAAGmL,OACT7J,EAAIA,EAAEsC,KAAIA,IAERzL,EAAM8H,GAAGgK,WACX9R,EAAM8H,GAAGkL,OACTnF,EAAOA,EAAKpC,KAAIA,IAGlBqH,EAAY,EAAJxW,GAAS6M,EACjB2J,EAAY,EAAJxW,EAAQ,GAAKuR,EACrBkF,EAAY,EAAJzW,GAAS0D,EAAM6H,GACvBkL,EAAY,EAAJzW,EAAQ,GAAK0D,EAAM8H,GAK7B,IAHA,IAAIrK,EAAMkF,KAAKsJ,YAAY,EAAG6G,EAASC,EAAa,EAAJzW,EAAO+P,GAG9C3O,EAAI,EAAGA,EAAQ,EAAJpB,EAAOoB,IACzBoV,EAAQpV,GAAK,KACbqV,EAAQrV,GAAK,KAEf,OAAOD,GAwBbyQ,EAAiBsB,EAAOpK,EAAKoF,WAE7BoE,EAAWjG,UAAUgC,MAAQ,SAAe2C,EAAGd,EAAGiD,GAChD,OAAO,IAAID,EAAM7M,KAAM2K,EAAGd,EAAGiD,IAG/Bb,EAAWjG,UAAUkB,cAAgB,SAAuBpB,EAAKW,GAC/D,OAAOoG,EAAMyD,SAAStQ,KAAM8F,EAAKW,IAGnCoG,EAAM7G,UAAUmF,SAAW,WACzB,GAAKnL,KAAK8H,MAAM0E,KAAhB,CAGA,IAAI+D,EAAMvQ,KAAK+H,YACf,GAAIwI,GAAOA,EAAIrF,KACb,OAAOqF,EAAIrF,KAEb,IAAIA,EAAOlL,KAAK8H,MAAME,MAAMhI,KAAK2K,EAAE8C,OAAOzN,KAAK8H,MAAM0E,KAAKtB,MAAOlL,KAAK6J,GACtE,GAAI0G,EAAK,CACP,IAAIzI,EAAQ9H,KAAK8H,MACb0I,EAAU,SAAShK,GACrB,OAAOsB,EAAME,MAAMxB,EAAEmE,EAAE8C,OAAO3F,EAAM0E,KAAKtB,MAAO1E,EAAEqD,IAEpD0G,EAAIrF,KAAOA,EACXA,EAAKnD,YAAc,CACjBmD,KAAM,KACN/G,IAAKoM,EAAIpM,KAAO,CACdgF,IAAKoH,EAAIpM,IAAIgF,IACbN,OAAQ0H,EAAIpM,IAAI0E,OAAOzM,IAAIoU,IAE7BrI,QAASoI,EAAIpI,SAAW,CACtBG,KAAMiI,EAAIpI,QAAQG,KAClBO,OAAQ0H,EAAIpI,QAAQU,OAAOzM,IAAIoU,KAIrC,OAAOtF,IAGT2B,EAAM7G,UAAUyK,OAAS,WACvB,OAAKzQ,KAAK+H,YAGH,CAAE/H,KAAK2K,EAAG3K,KAAK6J,EAAG7J,KAAK+H,aAAe,CAC3CI,QAASnI,KAAK+H,YAAYI,SAAW,CACnCG,KAAMtI,KAAK+H,YAAYI,QAAQG,KAC/BO,OAAQ7I,KAAK+H,YAAYI,QAAQU,OAAO9L,MAAM,IAEhDoH,IAAKnE,KAAK+H,YAAY5D,KAAO,CAC3BgF,IAAKnJ,KAAK+H,YAAY5D,IAAIgF,IAC1BN,OAAQ7I,KAAK+H,YAAY5D,IAAI0E,OAAO9L,MAAM,MATrC,CAAEiD,KAAK2K,EAAG3K,KAAK6J,IAc1BgD,EAAMyD,SAAW,SAAkBxI,EAAOhC,EAAKW,GAC1B,iBAARX,IACTA,EAAM4K,KAAKC,MAAM7K,IACnB,IAAIhL,EAAMgN,EAAME,MAAMlC,EAAI,GAAIA,EAAI,GAAIW,GACtC,IAAKX,EAAI,GACP,OAAOhL,EAET,SAAS8V,EAAU9K,GACjB,OAAOgC,EAAME,MAAMlC,EAAI,GAAIA,EAAI,GAAIW,GAGrC,IAAI8J,EAAMzK,EAAI,GAYd,OAXAhL,EAAIiN,YAAc,CAChBmD,KAAM,KACN/C,QAASoI,EAAIpI,SAAW,CACtBG,KAAMiI,EAAIpI,QAAQG,KAClBO,OAAQ,CAAE/N,GAAMiQ,OAAOwF,EAAIpI,QAAQU,OAAOzM,IAAIwU,KAEhDzM,IAAKoM,EAAIpM,KAAO,CACdgF,IAAKoH,EAAIpM,IAAIgF,IACbN,OAAQ,CAAE/N,GAAMiQ,OAAOwF,EAAIpM,IAAI0E,OAAOzM,IAAIwU,MAGvC9V,GAGT+R,EAAM7G,UAAU6K,QAAU,WACxB,OAAI7Q,KAAK8Q,aACA,sBACF,gBAAkB9Q,KAAK2K,EAAE0B,UAAUpQ,SAAS,GAAI,GACnD,OAAS+D,KAAK6J,EAAEwC,UAAUpQ,SAAS,GAAI,GAAK,KAGlD4Q,EAAM7G,UAAU8K,WAAa,WAC3B,OAAO9Q,KAAK+M,KAGdF,EAAM7G,UAAUrF,IAAM,SAAa6F,GAEjC,GAAIxG,KAAK+M,IACP,OAAOvG,EAGT,GAAIA,EAAEuG,IACJ,OAAO/M,KAGT,GAAIA,KAAKqK,GAAG7D,GACV,OAAOxG,KAAKsL,MAGd,GAAItL,KAAK8I,MAAMuB,GAAG7D,GAChB,OAAOxG,KAAK8H,MAAME,MAAM,KAAM,MAGhC,GAAwB,IAApBhI,KAAK2K,EAAEb,IAAItD,EAAEmE,GACf,OAAO3K,KAAK8H,MAAME,MAAM,KAAM,MAEhC,IAAIrN,EAAIqF,KAAK6J,EAAEmE,OAAOxH,EAAEqD,GACN,IAAdlP,EAAE6K,KAAK,KACT7K,EAAIA,EAAE8S,OAAOzN,KAAK2K,EAAEqD,OAAOxH,EAAEmE,GAAGwB,YAClC,IAAI4E,EAAKpW,EAAEkV,SAASI,QAAQjQ,KAAK2K,GAAGsF,QAAQzJ,EAAEmE,GAC1CqG,EAAKrW,EAAE8S,OAAOzN,KAAK2K,EAAEqD,OAAO+C,IAAKd,QAAQjQ,KAAK6J,GAClD,OAAO7J,KAAK8H,MAAME,MAAM+I,EAAIC,IAG9BnE,EAAM7G,UAAUsF,IAAM,WACpB,GAAItL,KAAK+M,IACP,OAAO/M,KAGT,IAAIiR,EAAMjR,KAAK6J,EAAEkE,OAAO/N,KAAK6J,GAC7B,GAAoB,IAAhBoH,EAAIzL,KAAK,GACX,OAAOxF,KAAK8H,MAAME,MAAM,KAAM,MAEhC,IAAIS,EAAIzI,KAAK8H,MAAMW,EAEfqG,EAAK9O,KAAK2K,EAAEkF,SACZqB,EAAQD,EAAI9E,UACZxR,EAAImU,EAAGf,OAAOe,GAAIgB,QAAQhB,GAAIgB,QAAQrH,GAAGgF,OAAOyD,GAEhDH,EAAKpW,EAAEkV,SAASI,QAAQjQ,KAAK2K,EAAEoD,OAAO/N,KAAK2K,IAC3CqG,EAAKrW,EAAE8S,OAAOzN,KAAK2K,EAAEqD,OAAO+C,IAAKd,QAAQjQ,KAAK6J,GAClD,OAAO7J,KAAK8H,MAAME,MAAM+I,EAAIC,IAG9BnE,EAAM7G,UAAU4E,KAAO,WACrB,OAAO5K,KAAK2K,EAAE0B,WAGhBQ,EAAM7G,UAAU6E,KAAO,WACrB,OAAO7K,KAAK6J,EAAEwC,WAGhBQ,EAAM7G,UAAUwH,IAAM,SAAa/I,GAEjC,OADAA,EAAI,IAAI,IAAGA,EAAG,IACVzE,KAAK8Q,aACA9Q,KACAA,KAAKoL,YAAY3G,GACjBzE,KAAK8H,MAAMI,aAAalI,KAAMyE,GAC9BzE,KAAK8H,MAAM0E,KACXxM,KAAK8H,MAAMoI,gBAAgB,CAAElQ,MAAQ,CAAEyE,IAEvCzE,KAAK8H,MAAMkB,SAAShJ,KAAMyE,IAGrCoI,EAAM7G,UAAUmL,OAAS,SAAgBjM,EAAIuK,EAAItK,GAC/C,IAAI0D,EAAS,CAAE7I,KAAMyP,GACjBjG,EAAS,CAAEtE,EAAIC,GACnB,OAAInF,KAAK8H,MAAM0E,KACNxM,KAAK8H,MAAMoI,gBAAgBrH,EAAQW,GAEnCxJ,KAAK8H,MAAMwB,YAAY,EAAGT,EAAQW,EAAQ,IAGrDqD,EAAM7G,UAAUoL,QAAU,SAAiBlM,EAAIuK,EAAItK,GACjD,IAAI0D,EAAS,CAAE7I,KAAMyP,GACjBjG,EAAS,CAAEtE,EAAIC,GACnB,OAAInF,KAAK8H,MAAM0E,KACNxM,KAAK8H,MAAMoI,gBAAgBrH,EAAQW,MAEnCxJ,KAAK8H,MAAMwB,YAAY,EAAGT,EAAQW,EAAQ,GAAE,IAGvDqD,EAAM7G,UAAUqE,GAAK,SAAY7D,GAC/B,OAAOxG,OAASwG,GACTxG,KAAK+M,MAAQvG,EAAEuG,MACV/M,KAAK+M,KAA2B,IAApB/M,KAAK2K,EAAEb,IAAItD,EAAEmE,IAAgC,IAApB3K,KAAK6J,EAAEC,IAAItD,EAAEqD,KAGhEgD,EAAM7G,UAAU8C,IAAM,SAAauI,GACjC,GAAIrR,KAAK+M,IACP,OAAO/M,KAET,IAAIlF,EAAMkF,KAAK8H,MAAME,MAAMhI,KAAK2K,EAAG3K,KAAK6J,EAAEG,UAC1C,GAAIqH,GAAerR,KAAK+H,YAAa,CACnC,IAAIwI,EAAMvQ,KAAK+H,YACXuJ,EAAS,SAAS9K,GACpB,OAAOA,EAAEsC,OAEXhO,EAAIiN,YAAc,CAChB5D,IAAKoM,EAAIpM,KAAO,CACdgF,IAAKoH,EAAIpM,IAAIgF,IACbN,OAAQ0H,EAAIpM,IAAI0E,OAAOzM,IAAIkV,IAE7BnJ,QAASoI,EAAIpI,SAAW,CACtBG,KAAMiI,EAAIpI,QAAQG,KAClBO,OAAQ0H,EAAIpI,QAAQU,OAAOzM,IAAIkV,KAIrC,OAAOxW,GAGT+R,EAAM7G,UAAU+D,IAAM,WACpB,OAAI/J,KAAK+M,IACA/M,KAAK8H,MAAMY,OAAO,KAAM,KAAM,MAE7B1I,KAAK8H,MAAMY,OAAO1I,KAAK2K,EAAG3K,KAAK6J,EAAG7J,KAAK8H,MAAMhB,MAwBzDyE,EAAiB0B,EAAQxK,EAAKoF,WAE9BoE,EAAWjG,UAAU0C,OAAS,SAAgBiC,EAAGd,EAAGlF,GAClD,OAAO,IAAIsI,EAAOjN,KAAM2K,EAAGd,EAAGlF,IAGhCsI,EAAOjH,UAAU+C,IAAM,WACrB,GAAI/I,KAAK8Q,aACP,OAAO9Q,KAAK8H,MAAME,MAAM,KAAM,MAEhC,IAAIuJ,EAAOvR,KAAK2E,EAAEwH,UACdqF,EAAQD,EAAK1B,SACbE,EAAK/P,KAAK2K,EAAE8C,OAAO+D,GACnBC,EAAKzR,KAAK6J,EAAE4D,OAAO+D,GAAO/D,OAAO8D,GAErC,OAAOvR,KAAK8H,MAAME,MAAM+H,EAAI0B,IAG9BxE,EAAOjH,UAAU8C,IAAM,WACrB,OAAO9I,KAAK8H,MAAMY,OAAO1I,KAAK2K,EAAG3K,KAAK6J,EAAEG,SAAUhK,KAAK2E,IAGzDsI,EAAOjH,UAAUrF,IAAM,SAAa6F,GAElC,GAAIxG,KAAK8Q,aACP,OAAOtK,EAGT,GAAIA,EAAEsK,aACJ,OAAO9Q,KAGT,IAAI0R,EAAMlL,EAAE7B,EAAEkL,SACV8B,EAAK3R,KAAK2E,EAAEkL,SACZpK,EAAKzF,KAAK2K,EAAE8C,OAAOiE,GACnBhM,EAAKc,EAAEmE,EAAE8C,OAAOkE,GAChBC,EAAK5R,KAAK6J,EAAE4D,OAAOiE,EAAIjE,OAAOjH,EAAE7B,IAChCkN,EAAKrL,EAAEqD,EAAE4D,OAAOkE,EAAGlE,OAAOzN,KAAK2E,IAE/B/G,EAAI6H,EAAGuI,OAAOtI,GACdvE,EAAIyQ,EAAG5D,OAAO6D,GAClB,GAAkB,IAAdjU,EAAE4H,KAAK,GACT,OAAkB,IAAdrE,EAAEqE,KAAK,GACFxF,KAAK8H,MAAMY,OAAO,KAAM,KAAM,MAE9B1I,KAAKsL,MAGhB,IAAIwG,EAAKlU,EAAEiS,SACPkC,EAAKD,EAAGrE,OAAO7P,GACfF,EAAI+H,EAAGgI,OAAOqE,GAEdf,EAAK5P,EAAE0O,SAASC,QAAQiC,GAAI9B,QAAQvS,GAAGuS,QAAQvS,GAC/CsT,EAAK7P,EAAEsM,OAAO/P,EAAEuS,QAAQc,IAAKd,QAAQ2B,EAAGnE,OAAOsE,IAC/CC,EAAKhS,KAAK2E,EAAE8I,OAAOjH,EAAE7B,GAAG8I,OAAO7P,GAEnC,OAAOoC,KAAK8H,MAAMY,OAAOqI,EAAIC,EAAIgB,IAGnC/E,EAAOjH,UAAU4C,SAAW,SAAkBpC,GAE5C,GAAIxG,KAAK8Q,aACP,OAAOtK,EAAEuD,MAGX,GAAIvD,EAAEsK,aACJ,OAAO9Q,KAGT,IAAI2R,EAAK3R,KAAK2E,EAAEkL,SACZpK,EAAKzF,KAAK2K,EACVjF,EAAKc,EAAEmE,EAAE8C,OAAOkE,GAChBC,EAAK5R,KAAK6J,EACVgI,EAAKrL,EAAEqD,EAAE4D,OAAOkE,GAAIlE,OAAOzN,KAAK2E,GAEhC/G,EAAI6H,EAAGuI,OAAOtI,GACdvE,EAAIyQ,EAAG5D,OAAO6D,GAClB,GAAkB,IAAdjU,EAAE4H,KAAK,GACT,OAAkB,IAAdrE,EAAEqE,KAAK,GACFxF,KAAK8H,MAAMY,OAAO,KAAM,KAAM,MAE9B1I,KAAKsL,MAGhB,IAAIwG,EAAKlU,EAAEiS,SACPkC,EAAKD,EAAGrE,OAAO7P,GACfF,EAAI+H,EAAGgI,OAAOqE,GAEdf,EAAK5P,EAAE0O,SAASC,QAAQiC,GAAI9B,QAAQvS,GAAGuS,QAAQvS,GAC/CsT,EAAK7P,EAAEsM,OAAO/P,EAAEuS,QAAQc,IAAKd,QAAQ2B,EAAGnE,OAAOsE,IAC/CC,EAAKhS,KAAK2E,EAAE8I,OAAO7P,GAEvB,OAAOoC,KAAK8H,MAAMY,OAAOqI,EAAIC,EAAIgB,IAGnC/E,EAAOjH,UAAUqD,KAAO,SAAc4I,GACpC,GAAY,IAARA,EACF,OAAOjS,KACT,GAAIA,KAAK8Q,aACP,OAAO9Q,KACT,IAAKiS,EACH,OAAOjS,KAAKsL,MAEd,IAAI3R,EACJ,GAAIqG,KAAK8H,MAAMsE,OAASpM,KAAK8H,MAAMwE,OAAQ,CACzC,IAAInL,EAAInB,KACR,IAAKrG,EAAI,EAAGA,EAAIsY,EAAKtY,IACnBwH,EAAIA,EAAEmK,MACR,OAAOnK,EAKT,IAAIsH,EAAIzI,KAAK8H,MAAMW,EACfyD,EAAOlM,KAAK8H,MAAMoE,KAElBgG,EAAKlS,KAAK2K,EACVwH,EAAKnS,KAAK6J,EACVuI,EAAKpS,KAAK2E,EACV0N,EAAMD,EAAGvC,SAASA,SAGlByC,EAAMH,EAAGpE,OAAOoE,GACpB,IAAKxY,EAAI,EAAGA,EAAIsY,EAAKtY,IAAK,CACxB,IAAI4Y,EAAML,EAAGrC,SACT2C,EAAOF,EAAIzC,SACX4C,EAAOD,EAAK3C,SACZlV,EAAI4X,EAAIxE,OAAOwE,GAAKzC,QAAQyC,GAAKzC,QAAQrH,EAAEgF,OAAO4E,IAElDK,EAAKR,EAAGzE,OAAO+E,GACfzB,EAAKpW,EAAEkV,SAASI,QAAQyC,EAAG3E,OAAO2E,IAClCC,EAAKD,EAAGzC,QAAQc,GAChB6B,EAAMjY,EAAE8S,OAAOkF,GACnBC,EAAMA,EAAI9C,QAAQ8C,GAAK3C,QAAQwC,GAC/B,IAAIT,EAAKM,EAAI7E,OAAO2E,GAChBzY,EAAI,EAAIsY,IACVI,EAAMA,EAAI5E,OAAOgF,IAEnBP,EAAKnB,EACLqB,EAAKJ,EACLM,EAAMM,EAGR,OAAO5S,KAAK8H,MAAMY,OAAOwJ,EAAII,EAAI7E,OAAOvB,GAAOkG,IAGjDnF,EAAOjH,UAAUsF,IAAM,WACrB,OAAItL,KAAK8Q,aACA9Q,KAELA,KAAK8H,MAAMsE,MACNpM,KAAK6S,WACL7S,KAAK8H,MAAMwE,OACXtM,KAAK8S,YAEL9S,KAAK+S,QAGhB9F,EAAOjH,UAAU6M,SAAW,WAC1B,IAAI9B,EACAC,EACAgB,EAEJ,GAAIhS,KAAKkN,KAAM,CAMb,IAAI8F,EAAKhT,KAAK2K,EAAEkF,SAEZoD,EAAKjT,KAAK6J,EAAEgG,SAEZqD,EAAOD,EAAGpD,SAEVvR,EAAI0B,KAAK2K,EAAEoD,OAAOkF,GAAIpD,SAASI,QAAQ+C,GAAI/C,QAAQiD,GACvD5U,EAAIA,EAAEwR,QAAQxR,GAEd,IAAI6U,EAAIH,EAAGjF,OAAOiF,GAAIlD,QAAQkD,GAE1BI,EAAID,EAAEtD,SAASI,QAAQ3R,GAAG2R,QAAQ3R,GAGlC+U,EAAQH,EAAKpD,QAAQoD,GAEzBG,GADAA,EAAQA,EAAMvD,QAAQuD,IACRvD,QAAQuD,GAGtBtC,EAAKqC,EAELpC,EAAKmC,EAAE1F,OAAOnP,EAAE2R,QAAQmD,IAAInD,QAAQoD,GAEpCrB,EAAKhS,KAAK6J,EAAEkE,OAAO/N,KAAK6J,OACnB,CAML,IAAIpB,EAAIzI,KAAK2K,EAAEkF,SAEXlH,EAAI3I,KAAK6J,EAAEgG,SAEXlV,EAAIgO,EAAEkH,SAEN7R,EAAIgC,KAAK2K,EAAEoD,OAAOpF,GAAGkH,SAASI,QAAQxH,GAAGwH,QAAQtV,GACrDqD,EAAIA,EAAE8R,QAAQ9R,GAEd,IAAIC,EAAIwK,EAAEsF,OAAOtF,GAAGqH,QAAQrH,GAExB6K,EAAIrV,EAAE4R,SAGN0D,EAAK5Y,EAAEmV,QAAQnV,GAEnB4Y,GADAA,EAAKA,EAAGzD,QAAQyD,IACRzD,QAAQyD,GAGhBxC,EAAKuC,EAAErD,QAAQjS,GAAGiS,QAAQjS,GAE1BgT,EAAK/S,EAAEwP,OAAOzP,EAAEiS,QAAQc,IAAKd,QAAQsD,GAGrCvB,GADAA,EAAKhS,KAAK6J,EAAE4D,OAAOzN,KAAK2E,IAChBmL,QAAQkC,GAGlB,OAAOhS,KAAK8H,MAAMY,OAAOqI,EAAIC,EAAIgB,IAGnC/E,EAAOjH,UAAU8M,UAAY,WAC3B,IAAI/B,EACAC,EACAgB,EAEJ,GAAIhS,KAAKkN,KAAM,CAMb,IAAI8F,EAAKhT,KAAK2K,EAAEkF,SAEZoD,EAAKjT,KAAK6J,EAAEgG,SAEZqD,EAAOD,EAAGpD,SAEVvR,EAAI0B,KAAK2K,EAAEoD,OAAOkF,GAAIpD,SAASI,QAAQ+C,GAAI/C,QAAQiD,GACvD5U,EAAIA,EAAEwR,QAAQxR,GAEd,IAAI6U,EAAIH,EAAGjF,OAAOiF,GAAIlD,QAAQkD,GAAIlD,QAAQ9P,KAAK8H,MAAMW,GAEjD2K,EAAID,EAAEtD,SAASI,QAAQ3R,GAAG2R,QAAQ3R,GAEtCyS,EAAKqC,EAEL,IAAIC,EAAQH,EAAKpD,QAAQoD,GAEzBG,GADAA,EAAQA,EAAMvD,QAAQuD,IACRvD,QAAQuD,GACtBrC,EAAKmC,EAAE1F,OAAOnP,EAAE2R,QAAQmD,IAAInD,QAAQoD,GAEpCrB,EAAKhS,KAAK6J,EAAEkE,OAAO/N,KAAK6J,OACnB,CAKL,IAAI2J,EAAQxT,KAAK2E,EAAEkL,SAEf4D,EAAQzT,KAAK6J,EAAEgG,SAEf3E,EAAOlL,KAAK2K,EAAE8C,OAAOgG,GAErBC,EAAQ1T,KAAK2K,EAAEqD,OAAOwF,GAAO/F,OAAOzN,KAAK2K,EAAEoD,OAAOyF,IACtDE,EAAQA,EAAM3F,OAAO2F,GAAO5D,QAAQ4D,GAEpC,IAAIC,EAAQzI,EAAK4E,QAAQ5E,GAErB0I,GADJD,EAAQA,EAAM7D,QAAQ6D,IACJ5F,OAAO4F,GACzB5C,EAAK2C,EAAM7D,SAASI,QAAQ2D,GAE5B5B,EAAKhS,KAAK6J,EAAEkE,OAAO/N,KAAK2E,GAAGkL,SAASI,QAAQwD,GAAOxD,QAAQuD,GAE3D,IAAIK,EAAUJ,EAAM5D,SAGpBgE,GADAA,GADAA,EAAUA,EAAQ/D,QAAQ+D,IACR/D,QAAQ+D,IACR/D,QAAQ+D,GAC1B7C,EAAK0C,EAAMjG,OAAOkG,EAAM1D,QAAQc,IAAKd,QAAQ4D,GAG/C,OAAO7T,KAAK8H,MAAMY,OAAOqI,EAAIC,EAAIgB,IAGnC/E,EAAOjH,UAAU+M,KAAO,WACtB,IAAItK,EAAIzI,KAAK8H,MAAMW,EAGfyJ,EAAKlS,KAAK2K,EACVwH,EAAKnS,KAAK6J,EACVuI,EAAKpS,KAAK2E,EACV0N,EAAMD,EAAGvC,SAASA,SAElB0C,EAAML,EAAGrC,SACTiE,EAAM3B,EAAGtC,SAETlV,EAAI4X,EAAIxE,OAAOwE,GAAKzC,QAAQyC,GAAKzC,QAAQrH,EAAEgF,OAAO4E,IAElD0B,EAAO7B,EAAGnE,OAAOmE,GAEjBQ,GADJqB,EAAOA,EAAKjE,QAAQiE,IACNtG,OAAOqG,GACjB/C,EAAKpW,EAAEkV,SAASI,QAAQyC,EAAG3E,OAAO2E,IAClCC,EAAKD,EAAGzC,QAAQc,GAEhBiD,EAAOF,EAAIjE,SAGfmE,GADAA,GADAA,EAAOA,EAAKlE,QAAQkE,IACRlE,QAAQkE,IACRlE,QAAQkE,GACpB,IAAIhD,EAAKrW,EAAE8S,OAAOkF,GAAI1C,QAAQ+D,GAC1BhC,EAAKG,EAAGpE,OAAOoE,GAAI1E,OAAO2E,GAE9B,OAAOpS,KAAK8H,MAAMY,OAAOqI,EAAIC,EAAIgB,IAGnC/E,EAAOjH,UAAUiO,KAAO,WACtB,IAAKjU,KAAK8H,MAAMsE,MACd,OAAOpM,KAAKsL,MAAM3K,IAAIX,MAMxB,IAAIgT,EAAKhT,KAAK2K,EAAEkF,SAEZoD,EAAKjT,KAAK6J,EAAEgG,SAEZqE,EAAKlU,KAAK2E,EAAEkL,SAEZqD,EAAOD,EAAGpD,SAEVsD,EAAIH,EAAGjF,OAAOiF,GAAIlD,QAAQkD,GAE1BmB,EAAKhB,EAAEtD,SAEP5R,EAAI+B,KAAK2K,EAAEoD,OAAOkF,GAAIpD,SAASI,QAAQ+C,GAAI/C,QAAQiD,GAKnDkB,GAFJnW,GADAA,GADAA,EAAIA,EAAE6R,QAAQ7R,IACR8P,OAAO9P,GAAG6R,QAAQ7R,IAClBgS,QAAQkE,IAEHtE,SAEPuD,EAAIF,EAAKpD,QAAQoD,GAGrBE,GADAA,GADAA,EAAIA,EAAEtD,QAAQsD,IACRtD,QAAQsD,IACRtD,QAAQsD,GAEd,IAAIzE,EAAIwE,EAAErD,QAAQ7R,GAAG4R,SAASI,QAAQkE,GAAIlE,QAAQmE,GAAInE,QAAQmD,GAE1DiB,EAAOpB,EAAGxF,OAAOkB,GAErB0F,GADAA,EAAOA,EAAKvE,QAAQuE,IACRvE,QAAQuE,GACpB,IAAItD,EAAK/Q,KAAK2K,EAAE8C,OAAO2G,GAAInE,QAAQoE,GAEnCtD,GADAA,EAAKA,EAAGjB,QAAQiB,IACRjB,QAAQiB,GAEhB,IAAIC,EAAKhR,KAAK6J,EAAE4D,OAAOkB,EAAElB,OAAO2F,EAAEnD,QAAQtB,IAAIsB,QAAQhS,EAAEwP,OAAO2G,KAG/DpD,GADAA,GADAA,EAAKA,EAAGlB,QAAQkB,IACRlB,QAAQkB,IACRlB,QAAQkB,GAEhB,IAAIgB,EAAKhS,KAAK2E,EAAEoJ,OAAO9P,GAAG4R,SAASI,QAAQiE,GAAIjE,QAAQmE,GAEvD,OAAOpU,KAAK8H,MAAMY,OAAOqI,EAAIC,EAAIgB,IAGnC/E,EAAOjH,UAAUwH,IAAM,SAAa/I,EAAG6P,GAGrC,OAFA7P,EAAI,IAAI,IAAGA,EAAG6P,GAEPtU,KAAK8H,MAAMkB,SAAShJ,KAAMyE,IAGnCwI,EAAOjH,UAAUqE,GAAK,SAAY7D,GAChC,GAAe,WAAXA,EAAEF,KACJ,OAAOtG,KAAKqK,GAAG7D,EAAEuD,OAEnB,GAAI/J,OAASwG,EACX,OAAM,EAGR,IAAImL,EAAK3R,KAAK2E,EAAEkL,SACZ6B,EAAMlL,EAAE7B,EAAEkL,SACd,GAA2D,IAAvD7P,KAAK2K,EAAE8C,OAAOiE,GAAKzB,QAAQzJ,EAAEmE,EAAE8C,OAAOkE,IAAKnM,KAAK,GAClD,OAAM,EAGR,IAAI+O,EAAK5C,EAAGlE,OAAOzN,KAAK2E,GACpB6P,EAAM9C,EAAIjE,OAAOjH,EAAE7B,GACvB,OAA8D,IAAvD3E,KAAK6J,EAAE4D,OAAO+G,GAAKvE,QAAQzJ,EAAEqD,EAAE4D,OAAO8G,IAAK/O,KAAK,IAGzDyH,EAAOjH,UAAUyO,OAAS,SAAgB9J,GACxC,IAAI+J,EAAK1U,KAAK2E,EAAEkL,SACZ8E,EAAKhK,EAAE9D,MAAM7G,KAAK8H,MAAMrB,KAAKgH,OAAOiH,GACxC,GAAuB,IAAnB1U,KAAK2K,EAAEb,IAAI6K,GACb,OAAM,EAIR,IAFA,IAAIC,EAAKjK,EAAEjG,QACP0O,EAAIpT,KAAK8H,MAAMH,KAAK8F,OAAOiH,KACtB,CAEP,GADAE,EAAGC,KAAK7U,KAAK8H,MAAMd,GACf4N,EAAG9K,IAAI9J,KAAK8H,MAAMtB,IAAM,EAC1B,OAAM,EAGR,GADAmO,EAAG7E,QAAQsD,GACY,IAAnBpT,KAAK2K,EAAEb,IAAI6K,GACb,OAAM,IAIZ1H,EAAOjH,UAAU6K,QAAU,WACzB,OAAI7Q,KAAK8Q,aACA,uBACF,iBAAmB9Q,KAAK2K,EAAE1O,SAAS,GAAI,GAC1C,OAAS+D,KAAK6J,EAAE5N,SAAS,GAAI,GAC7B,OAAS+D,KAAK2E,EAAE1I,SAAS,GAAI,GAAK,KAGxCgR,EAAOjH,UAAU8K,WAAa,WAE5B,OAA0B,IAAnB9Q,KAAK2E,EAAEa,KAAK,IAGrB,IAAIsP,EAAU5S,YAA+BG,EAAQE,GAGrD,IAAIuF,EAAQvF,EAEZuF,EAAMrF,KAAOA,EACbqF,EAAMiN,MAAQnI,EACd9E,EAAMnB,KAAwC,KAC9CmB,EAAMkN,QAA8C,QAGhDC,EAAW/S,YAA+BG,EAAQE,GAGtD,IAsKIgO,EAtKA2E,EAAS3S,EAMTS,EAASc,EAAUd,OAEvB,SAASmS,EAAYC,GACE,UAAjBA,EAAQ9O,KACVtG,KAAK8H,MAAQ,IAAIgN,EAAQC,MAAMK,GACP,YAAjBA,EAAQ9O,KACftG,KAAK8H,MAAQ,IAAIgN,EAAQE,QAAQI,GAEjCpV,KAAK8H,MAAQ,IAAIgN,EAAQnO,KAAKyO,GAChCpV,KAAKiH,EAAIjH,KAAK8H,MAAMb,EACpBjH,KAAKgH,EAAIhH,KAAK8H,MAAMd,EACpBhH,KAAKqV,KAAOD,EAAQC,KAEpBrS,EAAOhD,KAAKiH,EAAEgB,WAAY,iBAC1BjF,EAAOhD,KAAKiH,EAAEuG,IAAIxN,KAAKgH,GAAG8J,aAAc,2BAI1C,SAASwE,EAAY3V,EAAMyV,GACzBpb,OAAOub,eAAeL,EAAQvV,EAAM,CAClCmM,cAAaA,EACbF,YAAWA,EACX4J,IAAK,WACH,IAAI1N,EAAQ,IAAIqN,EAAYC,GAM5B,OALApb,OAAOub,eAAeL,EAAQvV,EAAM,CAClCmM,cAAaA,EACbF,YAAWA,EACX7P,MAAO+L,IAEFA,KAbboN,EAAOC,YAAcA,EAkBrBG,EAAY,OAAQ,CAClBhP,KAAM,QACNI,MAAO,OACPF,EAAG,wDACHiC,EAAG,wDACHE,EAAG,wDACH3B,EAAG,wDACHqO,KAAM,IAAK9c,OACX4O,MAAKA,EACLF,EAAG,CACD,wDACA,2DAIJqO,EAAY,OAAQ,CAClBhP,KAAM,QACNI,MAAO,OACPF,EAAG,iEACHiC,EAAG,iEACHE,EAAG,iEACH3B,EAAG,iEACHqO,KAAM,IAAK9c,OACX4O,MAAKA,EACLF,EAAG,CACD,iEACA,oEAIJqO,EAAY,OAAQ,CAClBhP,KAAM,QACNI,MAAO,KACPF,EAAG,0EACHiC,EAAG,0EACHE,EAAG,0EACH3B,EAAG,0EACHqO,KAAM,IAAK9c,OACX4O,MAAKA,EACLF,EAAG,CACD,0EACA,6EAIJqO,EAAY,OAAQ,CAClBhP,KAAM,QACNI,MAAO,KACPF,EAAG,8GAEHiC,EAAG,8GAEHE,EAAG,8GAEH3B,EAAG,8GAEHqO,KAAM,IAAKI,OACXtO,MAAKA,EACLF,EAAG,CACD,8GAEA,iHAKJqO,EAAY,OAAQ,CAClBhP,KAAM,QACNI,MAAO,KACPF,EAAG,2JAGHiC,EAAG,2JAGHE,EAAG,2JAGH3B,EAAG,2JAGHqO,KAAM,IAAK7c,OACX2O,MAAKA,EACLF,EAAG,CACD,2JAGA,8JAMJqO,EAAY,aAAc,CACxBhP,KAAM,OACNI,MAAO,SACPF,EAAG,sEACHiC,EAAG,QACHE,EAAG,IACH3B,EAAG,sEACHqO,KAAM,IAAK9c,OACX4O,MAAKA,EACLF,EAAG,CACD,OAIJqO,EAAY,UAAW,CACrBhP,KAAM,UACNI,MAAO,SACPF,EAAG,sEACHiC,EAAG,KACH9N,EAAG,IAEHqD,EAAG,sEACHgJ,EAAG,sEACHqO,KAAM,IAAK9c,OACX4O,MAAKA,EACLF,EAAG,CACD,mEAGA,sEAKJ,IACEsJ,EAAwD,KAAOmF,QAC/D,MAAOzX,GACPsS,SAGF+E,EAAY,YAAa,CACvBhP,KAAM,QACNI,MAAO,OACPF,EAAG,0EACHiC,EAAG,IACHE,EAAG,IACH3B,EAAG,0EACHpJ,EAAG,IACHyX,KAAM,IAAK9c,OAGX2S,KAAM,mEACNkC,OAAQ,mEACRM,MAAO,CACL,CACEjF,EAAG,mCACHE,EAAG,qCAEL,CACEF,EAAG,oCACHE,EAAG,qCAIPxB,MAAKA,EACLF,EAAG,CACD,mEACA,mEACAsJ,QAWJ,SAASoF,EAASP,GAChB,KAAMpV,gBAAgB2V,GACpB,OAAO,IAAIA,EAASP,GACtBpV,KAAKqV,KAAOD,EAAQC,KACpBrV,KAAK4V,aAAeR,EAAQQ,WAE5B5V,KAAK6V,OAAS7V,KAAKqV,KAAKS,QACxB9V,KAAK+V,WAAaX,EAAQW,YAAc/V,KAAKqV,KAAKW,aAElDhW,KAAKiW,QAAU,KACfjW,KAAKkW,eAAiB,KACtBlW,KAAKmW,EAAI,KACTnW,KAAKoW,EAAI,KAET,IAAIC,EAAUjT,EAAQK,QAAQ2R,EAAQiB,QAASjB,EAAQkB,YAAc,OACjEC,EAAQnT,EAAQK,QAAQ2R,EAAQmB,MAAOnB,EAAQoB,UAAY,OAC3DC,EAAOrT,EAAQK,QAAQ2R,EAAQqB,KAAMrB,EAAQsB,SAAW,OAC5D3T,EAAmBsT,EAAQxc,QAAWmG,KAAK+V,WAAa,EACjD,mCAAqC/V,KAAK+V,WAAa,SAC9D/V,KAAK2W,MAAMN,EAASE,EAAOE,GAE7B,IAAIG,EAAWjB,EAEfA,EAAS3P,UAAU2Q,MAAQ,SAAcN,EAASE,EAAOE,GACvD,IAAII,EAAOR,EAAQtL,OAAOwL,GAAOxL,OAAO0L,GAExCzW,KAAKmW,EAAI,IAAIxS,MAAM3D,KAAK6V,OAAS,GACjC7V,KAAKoW,EAAI,IAAIzS,MAAM3D,KAAK6V,OAAS,GACjC,IAAK,IAAIlc,EAAI,EAAGA,EAAIqG,KAAKoW,EAAEvc,OAAQF,IACjCqG,KAAKmW,EAAExc,GAAK,EACZqG,KAAKoW,EAAEzc,GAAK,EAGdqG,KAAK8W,QAAQD,GACb7W,KAAKiW,QAAU,EACfjW,KAAKkW,eAAiB,iBAGxBP,EAAS3P,UAAU+Q,MAAQ,WACzB,OAAO,IAAI,IAAK/d,KAAKgH,KAAKqV,KAAMrV,KAAKmW,IAGvCR,EAAS3P,UAAU8Q,QAAU,SAAgBD,GAC3C,IAAIG,EAAOhX,KAAK+W,QACA1e,OAAO2H,KAAKoW,GACZ/d,OAAO,CAAE,IACrBwe,IACFG,EAAOA,EAAK3e,OAAOwe,IACrB7W,KAAKmW,EAAIa,EAAK1e,SACd0H,KAAKoW,EAAIpW,KAAK+W,QAAQ1e,OAAO2H,KAAKoW,GAAG9d,SAChCue,IAGL7W,KAAKmW,EAAInW,KAAK+W,QACA1e,OAAO2H,KAAKoW,GACZ/d,OAAO,CAAE,IACTA,OAAOwe,GACPve,SACd0H,KAAKoW,EAAIpW,KAAK+W,QAAQ1e,OAAO2H,KAAKoW,GAAG9d,WAGvCqd,EAAS3P,UAAUiR,OAAS,SAAgBZ,EAASC,EAAY3V,EAAKuW,GAE1C,iBAAfZ,IACTY,EAASvW,EACTA,EAAM2V,EACNA,EAAa,MAGfD,EAAUjT,EAAQK,QAAQ4S,EAASC,GACnC3V,EAAMyC,EAAQK,QAAQ9C,EAAKuW,GAE3BnU,EAAmBsT,EAAQxc,QAAWmG,KAAK+V,WAAa,EACjD,mCAAqC/V,KAAK+V,WAAa,SAE9D/V,KAAK8W,QAAQT,EAAQtL,OAAOpK,GAAO,KACnCX,KAAKiW,QAAU,GAGjBN,EAAS3P,UAAUmR,SAAW,SAAkB1N,EAAK/F,EAAK/C,EAAKuW,GAC7D,GAAIlX,KAAKiW,QAAUjW,KAAKkW,eACtB,MAAM,IAAIta,MAAM,sBAGC,iBAAR8H,IACTwT,EAASvW,EACTA,EAAM+C,EACNA,EAAM,MAIJ/C,IACFA,EAAMyC,EAAQK,QAAQ9C,EAAKuW,GAAU,OACrClX,KAAK8W,QAAQnW,IAIf,IADA,IAAIyW,EAAO,GACJA,EAAKvd,OAAS4P,GACnBzJ,KAAKoW,EAAIpW,KAAK+W,QAAQ1e,OAAO2H,KAAKoW,GAAG9d,SACrC8e,EAAOA,EAAKrM,OAAO/K,KAAKoW,GAG1B,IAAItb,EAAMsc,EAAKra,MAAM,EAAG0M,GAGxB,OAFAzJ,KAAK8W,QAAQnW,GACbX,KAAKiW,UACE7S,EAAQrB,OAAOjH,EAAK4I,IAO7B,IAAI2T,EAAWvT,EAAUd,OAEzB,SAASsU,EAAQC,EAAInC,GACnBpV,KAAKuX,GAAKA,EACVvX,KAAKwX,KAAO,KACZxX,KAAKU,IAAM,KAGP0U,EAAQoC,MACVxX,KAAKyX,eAAerC,EAAQoC,KAAMpC,EAAQsC,SACxCtC,EAAQ1U,KACVV,KAAK2X,cAAcvC,EAAQ1U,IAAK0U,EAAQwC,QAE5C,IAAIjf,EAAM2e,EAEVA,EAAQO,WAAa,SAAoBN,EAAI7W,EAAKgD,GAChD,OAAIhD,aAAe4W,EACV5W,EAEF,IAAI4W,EAAQC,EAAI,CACrB7W,IAAKA,EACLkX,OAAQlU,KAIZ4T,EAAQQ,YAAc,SAAqBP,EAAIC,EAAM9T,GACnD,OAAI8T,aAAgBF,EACXE,EAEF,IAAIF,EAAQC,EAAI,CACrBC,KAAMA,EACNE,QAAShU,KAIb4T,EAAQtR,UAAUiC,SAAW,WAC3B,IAAIvH,EAAMV,KAAKG,YAEf,OAAIO,EAAIoQ,aACC,CAAEpW,QAAOA,EAAQtB,OAAQ,sBAC7BsH,EAAIuH,WAEJvH,EAAI8M,IAAIxN,KAAKuX,GAAGzP,MAAMd,GAAG8J,aAGvB,CAAEpW,QAAOA,EAAOtB,OAAQ,MAFtB,CAAEsB,QAAOA,EAAQtB,OAAQ,uBAFzB,CAAEsB,QAAOA,EAAQtB,OAAQ,8BAOpCke,EAAQtR,UAAU7F,UAAY,SAAmBuK,EAAShH,GAUxD,MARuB,iBAAZgH,IACThH,EAAMgH,EACNA,EAAU,MAGP1K,KAAKU,MACRV,KAAKU,IAAMV,KAAKuX,GAAGtQ,EAAEuG,IAAIxN,KAAKwX,OAE3B9T,EAGE1D,KAAKU,IAAIqB,OAAO2B,EAAKgH,GAFnB1K,KAAKU,KAKhB4W,EAAQtR,UAAU+R,WAAa,SAAoBrU,GACjD,MAAY,QAARA,EACK1D,KAAKwX,KAAKvb,SAAS,GAAI,GAEvB+D,KAAKwX,MAGhBF,EAAQtR,UAAUyR,eAAiB,SAAwB9e,EAAK+K,GAC9D1D,KAAKwX,KAAO,IAAI,IAAG7e,EAAK+K,GAAO,IAI/B1D,KAAKwX,KAAOxX,KAAKwX,KAAKQ,KAAKhY,KAAKuX,GAAGzP,MAAMd,IAG3CsQ,EAAQtR,UAAU2R,cAAgB,SAAuBhf,EAAK+K,GAC5D,GAAI/K,EAAIgS,GAAKhS,EAAIkR,EAWf,MAP2B,SAAvB7J,KAAKuX,GAAGzP,MAAMxB,KAChB+Q,EAAS1e,EAAIgS,EAAG,qBACgB,UAAvB3K,KAAKuX,GAAGzP,MAAMxB,MACS,YAAvBtG,KAAKuX,GAAGzP,MAAMxB,MACvB+Q,EAAS1e,EAAIgS,GAAKhS,EAAIkR,EAAG,qCAE3B7J,KAAKU,IAAMV,KAAKuX,GAAGzP,MAAME,MAAMrP,EAAIgS,EAAGhS,EAAIkR,IAG5C7J,KAAKU,IAAMV,KAAKuX,GAAGzP,MAAMwC,YAAY3R,EAAK+K,IAI5C4T,EAAQtR,UAAUxE,OAAS,SAAgBd,GAIzC,OAHIA,EAAIuH,YACNoP,EAAS3W,EAAIuH,WAAY,8BAEpBvH,EAAI8M,IAAIxN,KAAKwX,MAAM5M,QAI5B0M,EAAQtR,UAAUhF,KAAO,SAAckC,EAAKQ,EAAK0R,GAC/C,OAAOpV,KAAKuX,GAAGvW,KAAKkC,EAAKlD,KAAM0D,EAAK0R,IAGtCkC,EAAQtR,UAAUiS,OAAS,SAAgB/U,EAAKnC,GAC9C,OAAOf,KAAKuX,GAAGU,OAAO/U,EAAKnC,EAAWf,OAGxCsX,EAAQtR,UAAU6K,QAAU,WAC1B,MAAO,eAAiB7Q,KAAKwX,MAAQxX,KAAKwX,KAAKvb,SAAS,GAAI,IACrD,UAAY+D,KAAKU,KAAOV,KAAKU,IAAImQ,WAAa,MAQvD,IAAIqH,EAAWpU,EAAUd,OAEzB,SAASmV,EAAU/C,EAAS1R,GAC1B,GAAI0R,aAAmB+C,EACrB,OAAO/C,EAELpV,KAAKoY,WAAWhD,EAAS1R,KAG7BwU,EAAS9C,EAAQjU,GAAKiU,EAAQ9W,EAAG,4BACjC0B,KAAKmB,EAAI,IAAI,IAAGiU,EAAQjU,EAAG,IAC3BnB,KAAK1B,EAAI,IAAI,IAAG8W,EAAQ9W,EAAG,aACvB8W,EAAQlU,cACVlB,KAAKkB,cAAgB,KAErBlB,KAAKkB,cAAgBkU,EAAQlU,eAEjC,IAAIH,EAAYoX,EAEhB,SAASE,IACPrY,KAAKsY,MAAQ,EAGf,SAASC,EAAUC,EAAKhS,GACtB,IAAIiS,EAAUD,EAAIhS,EAAE8R,SACpB,KAAgB,IAAVG,GACJ,OAAOA,EAET,IAAIC,EAAqB,GAAVD,EAGf,GAAiB,IAAbC,GAAkBA,EAAW,EAC/B,OAAM,EAIR,IADA,IAAIzV,EAAM,EACDtJ,EAAI,EAAGgf,EAAMnS,EAAE8R,MAAO3e,EAAI+e,EAAU/e,IAAKgf,IAChD1V,IAAQ,EACRA,GAAOuV,EAAIG,GACX1V,KAAS,EAIX,QAAIA,GAAO,OAIXuD,EAAE8R,MAAQK,EACH1V,GAGT,SAAS2V,EAAUJ,GAGjB,IAFA,IAAI7e,EAAI,EACJ8P,EAAM+O,EAAI3e,OAAS,GACf2e,EAAI7e,MAAqB,IAAb6e,EAAI7e,EAAI,KAAcA,EAAI8P,GAC5C9P,IAEF,OAAU,IAANA,EACK6e,EAEFA,EAAIzb,MAAMpD,GA4DnB,SAASkf,EAAgBhV,EAAK4F,GAC5B,GAAIA,EAAM,IACR5F,EAAItJ,KAAKkP,OADX,CAIA,IAAIqP,EAAS,GAAK1U,KAAK2U,IAAItP,GAAOrF,KAAK4U,MAAQ,GAE/C,IADAnV,EAAItJ,KAAc,IAATue,KACAA,GACPjV,EAAItJ,KAAMkP,KAASqP,GAAU,GAAM,KAErCjV,EAAItJ,KAAKkP,IAnEX0O,EAAUnS,UAAUoS,WAAa,SAAoBhgB,EAAMsL,GACzDtL,EAAO0L,EAAUL,QAAQrL,EAAMsL,GAC/B,IAAI8C,EAAI,IAAI6R,EACZ,GAAwB,KAApBjgB,EAAKoO,EAAE8R,SACT,OAAM,EAER,IAAI7O,EAAM8O,EAAUngB,EAAMoO,GAC1B,QAAIiD,EACF,OAAM,EAER,GAAKA,EAAMjD,EAAE8R,QAAWlgB,EAAKyB,OAC3B,OAAM,EAER,GAAwB,IAApBzB,EAAKoO,EAAE8R,SACT,OAAM,EAER,IAAIW,EAAOV,EAAUngB,EAAMoO,GAC3B,QAAIyS,EACF,OAAM,EAER,IAAI9X,EAAI/I,EAAK2E,MAAMyJ,EAAE8R,MAAOW,EAAOzS,EAAE8R,OAErC,GADA9R,EAAE8R,OAASW,EACa,IAApB7gB,EAAKoO,EAAE8R,SACT,OAAM,EAER,IAAIY,EAAOX,EAAUngB,EAAMoO,GAC3B,QAAI0S,EACF,OAAM,EAER,GAAI9gB,EAAKyB,SAAWqf,EAAO1S,EAAE8R,MAC3B,OAAM,EAER,IAAIha,EAAIlG,EAAK2E,MAAMyJ,EAAE8R,MAAOY,EAAO1S,EAAE8R,OACrC,GAAa,IAATnX,EAAE,GAAU,CACd,KAAW,IAAPA,EAAE,IAIJ,OAAM,EAHNA,EAAIA,EAAEpE,MAAM,GAMhB,GAAa,IAATuB,EAAE,GAAU,CACd,KAAW,IAAPA,EAAE,IAIJ,OAAM,EAHNA,EAAIA,EAAEvB,MAAM,GAWhB,OAJAiD,KAAKmB,EAAI,IAAI,IAAGA,GAChBnB,KAAK1B,EAAI,IAAI,IAAGA,GAChB0B,KAAKkB,cAAgB,SAkBvBiX,EAAUnS,UAAUmT,MAAQ,SAAezV,GACzC,IAAIvC,EAAInB,KAAKmB,EAAEsC,UACXnF,EAAI0B,KAAK1B,EAAEmF,UAYf,IATW,IAAPtC,EAAE,KACJA,EAAI,CAAE,GAAI4J,OAAO5J,IAER,IAAP7C,EAAE,KACJA,EAAI,CAAE,GAAIyM,OAAOzM,IAEnB6C,EAAIyX,EAAUzX,GACd7C,EAAIsa,EAAUta,KAENA,EAAE,IAAe,IAAPA,EAAE,KAClBA,EAAIA,EAAEvB,MAAM,GAEd,IAAI8G,EAAM,CAAE,GACZgV,EAAgBhV,EAAK1C,EAAEtH,SACvBgK,EAAMA,EAAIkH,OAAO5J,IACb5G,KAAK,GACTse,EAAgBhV,EAAKvF,EAAEzE,QACvB,IAAIuf,EAAWvV,EAAIkH,OAAOzM,GACtBxD,EAAM,CAAE,IAGZ,OAFA+d,EAAgB/d,EAAKse,EAASvf,QAC9BiB,EAAMA,EAAIiQ,OAAOqO,GACVtV,EAAU/B,OAAOjH,EAAK4I,IAS/B,IAAI2V,EAAyC,WAAc,MAAM,IAAIzd,MAAM,gBACvE0d,EAAWxV,EAAUd,OAKzB,SAASuW,EAAGnE,GACV,KAAMpV,gBAAgBuZ,GACpB,OAAO,IAAIA,EAAGnE,GAGO,iBAAZA,IACTkE,EAAStf,OAAOgM,UAAUwT,eAAevT,KAAKgP,EAAUG,GACtD,iBAAmBA,GAErBA,EAAUH,EAASG,IAIjBA,aAAmBH,EAASE,cAC9BC,EAAU,CAAEtN,MAAOsN,IAErBpV,KAAK8H,MAAQsN,EAAQtN,MAAMA,MAC3B9H,KAAKgH,EAAIhH,KAAK8H,MAAMd,EACpBhH,KAAKyZ,GAAKzZ,KAAKgH,EAAEyH,MAAM,GACvBzO,KAAKiH,EAAIjH,KAAK8H,MAAMb,EAGpBjH,KAAKiH,EAAImO,EAAQtN,MAAMb,EACvBjH,KAAKiH,EAAE+D,WAAWoK,EAAQtN,MAAMd,EAAE1C,YAAc,GAGhDtE,KAAKqV,KAAOD,EAAQC,MAAQD,EAAQtN,MAAMuN,KAE5C,IAAIkC,EAAKgC,EAETA,EAAGvT,UAAU/F,QAAU,SAAiBmV,GACtC,OAAO,IAAIzc,EAAIqH,KAAMoV,IAGvBmE,EAAGvT,UAAU9F,eAAiB,SAAwBsX,EAAM9T,GAC1D,OAAO/K,EAAImf,YAAY9X,KAAMwX,EAAM9T,IAGrC6V,EAAGvT,UAAUzF,cAAgB,SAAuBG,EAAKgD,GACvD,OAAO/K,EAAIkf,WAAW7X,KAAMU,EAAKgD,IAGnC6V,EAAGvT,UAAU0T,WAAa,SAAoBtE,GACvCA,IACHA,EAAU,IAcZ,IAXA,IAAIuE,EAAO,IAAI/C,EAAS,CACtBvB,KAAMrV,KAAKqV,KACXoB,KAAMrB,EAAQqB,KACdC,QAAStB,EAAQsB,SAAW,OAC5BL,QAASjB,EAAQiB,SAAWgD,EAAKrZ,KAAKqV,KAAKW,cAC3CM,WAAYlB,EAAQiB,SAAWjB,EAAQkB,YAAc,OACrDC,MAAOvW,KAAKgH,EAAEvD,YAGZnK,EAAQ0G,KAAKgH,EAAEuD,aACfqP,EAAM5Z,KAAKgH,EAAEuF,IAAI,IAAI,IAAG,MACnB,CACP,IAAIiL,EAAO,IAAI,IAAGmC,EAAKxC,SAAS7d,IAChC,KAAIke,EAAK1N,IAAI8P,GAAO,GAIpB,OADApC,EAAKqC,MAAM,GACJ7Z,KAAKE,eAAesX,KAI/B+B,EAAGvT,UAAU8T,aAAe,SAAsB5W,EAAK6W,GACrD,IAAIvG,EAA2B,EAAnBtQ,EAAIqH,aAAmBvK,KAAKgH,EAAE1C,YAG1C,OAFIkP,EAAQ,IACVtQ,EAAMA,EAAIuL,MAAM+E,KACbuG,GAAa7W,EAAI4G,IAAI9J,KAAKgH,IAAM,EAC5B9D,EAAIqJ,IAAIvM,KAAKgH,GAEb9D,GAGXqW,EAAGvT,UAAUhF,KAAO,SAAckC,EAAKvK,EAAK+K,EAAK0R,GAC5B,iBAAR1R,IACT0R,EAAU1R,EACVA,EAAM,MAEH0R,IACHA,EAAU,IAEZzc,EAAMqH,KAAKE,eAAevH,EAAK+K,GAC/BR,EAAMlD,KAAK8Z,aAAa,IAAI,IAAG5W,EAAK,KAqBpC,IAlBA,IAAI5J,EAAQ0G,KAAKgH,EAAEuD,aACfyP,EAAOrhB,EAAIof,aAAatU,QAAQ,KAAMnK,GAGtCid,EAAQrT,EAAIO,QAAQ,KAAMnK,GAG1BqgB,EAAO,IAAI/C,EAAS,CACtBvB,KAAMrV,KAAKqV,KACXgB,QAAS2D,EACTzD,MAAOA,EACPE,KAAMrB,EAAQqB,KACdC,QAAStB,EAAQsB,SAAW,SAI1BuD,EAAMja,KAAKgH,EAAEuF,IAAI,IAAI,IAAG,IAEnB2N,EAAO,GAAKA,IAAQ,CAC3B,IAAIzV,EAAI2Q,EAAQ3Q,EACd2Q,EAAQ3Q,EAAEyV,GACV,IAAI,IAAGP,EAAKxC,SAASnX,KAAKgH,EAAEuD,eAE9B,MADA9F,EAAIzE,KAAK8Z,aAAarV,OAChBe,KAAK,IAAM,GAAKf,EAAEqF,IAAImQ,IAAQ,GAApC,CAGA,IAAIE,EAAKna,KAAKiH,EAAEuG,IAAI/I,GACpB,IAAI0V,EAAGrJ,aAAP,CAGA,IAAIsJ,EAAMD,EAAGvP,OACTzJ,EAAIiZ,EAAIpC,KAAKhY,KAAKgH,GACtB,GAAkB,IAAd7F,EAAEqE,KAAK,GAAX,CAGA,IAAIlH,EAAImG,EAAE4V,KAAKra,KAAKgH,GAAGwG,IAAIrM,EAAEqM,IAAI7U,EAAIof,cAAclD,KAAK3R,IAExD,GAAkB,KADlB5E,EAAIA,EAAE0Z,KAAKhY,KAAKgH,IACVxB,KAAK,GAAX,CAGA,IAAItE,GAAiBiZ,EAAGtP,OAAO/F,QAAU,EAAI,IACT,IAAfsV,EAAItQ,IAAI3I,GAAW,EAAI,GAQ5C,OALIiU,EAAQnU,WAAa3C,EAAEwL,IAAI9J,KAAKyZ,IAAM,IACxCnb,EAAI0B,KAAKgH,EAAEuF,IAAIjO,GACf4C,GAAiB,GAGZ,IAAIH,EAAU,CAAEI,EAAGA,EAAG7C,EAAGA,EAAG4C,cAAeA,UAItDqY,EAAGvT,UAAUiS,OAAS,SAAgB/U,EAAKoX,EAAa3hB,EAAK+K,GAC3DR,EAAMlD,KAAK8Z,aAAa,IAAI,IAAG5W,EAAK,KACpCvK,EAAMqH,KAAKO,cAAc5H,EAAK+K,GAI9B,IAAIvC,GAHJmZ,EAAc,IAAIvZ,EAAUuZ,EAAa,QAGrBnZ,EAChB7C,EAAIgc,EAAYhc,EACpB,GAAI6C,EAAEqE,KAAK,GAAK,GAAKrE,EAAE2I,IAAI9J,KAAKgH,IAAM,EACpC,OAAM,EACR,GAAI1I,EAAEkH,KAAK,GAAK,GAAKlH,EAAEwL,IAAI9J,KAAKgH,IAAM,EACpC,OAAM,EAGR,IAGIR,EAHA+T,EAAOjc,EAAE+b,KAAKra,KAAKgH,GACnBvB,EAAK8U,EAAK/M,IAAItK,GAAK8U,KAAKhY,KAAKgH,GAC7BtB,EAAK6U,EAAK/M,IAAIrM,GAAG6W,KAAKhY,KAAKgH,GAG/B,OAAKhH,KAAK8H,MAAMF,gBAWhBpB,EAAIxG,KAAKiH,EAAEmK,QAAQ3L,EAAI9M,EAAIwH,YAAauF,IAClCoL,cAMCtK,EAAEiO,OAAOtT,KAjBdqF,EAAIxG,KAAKiH,EAAEkK,OAAO1L,EAAI9M,EAAIwH,YAAauF,IACjCoL,cAGkC,IAAjCtK,EAAEoE,OAAOoN,KAAKhY,KAAKgH,GAAG8C,IAAI3I,IAgBrCoY,EAAGvT,UAAUlE,cAAgB,SAASoB,EAAKoX,EAAavf,EAAG2I,GACzD4V,GAAU,EAAIve,KAAOA,EAAG,4CACxBuf,EAAc,IAAIvZ,EAAUuZ,EAAa5W,GAEzC,IAAIsD,EAAIhH,KAAKgH,EACT/I,EAAI,IAAI,IAAGiF,GACX/B,EAAImZ,EAAYnZ,EAChB7C,EAAIgc,EAAYhc,EAGhBkc,EAAa,EAAJzf,EACT0f,EAAc1f,GAAK,EACvB,GAAIoG,EAAE2I,IAAI9J,KAAK8H,MAAMtB,EAAEwR,KAAKhY,KAAK8H,MAAMd,KAAO,GAAKyT,EACjD,MAAM,IAAI7e,MAAM,wCAIhBuF,EADEsZ,EACEza,KAAK8H,MAAM0C,WAAWrJ,EAAER,IAAIX,KAAK8H,MAAMd,GAAIwT,GAE3Cxa,KAAK8H,MAAM0C,WAAWrJ,EAAGqZ,GAE/B,IAAIE,EAAOJ,EAAYnZ,EAAEkZ,KAAKrT,GAC1B4K,EAAK5K,EAAEuF,IAAItO,GAAGuP,IAAIkN,GAAM1C,KAAKhR,GAC7B6K,EAAKvT,EAAEkP,IAAIkN,GAAM1C,KAAKhR,GAI1B,OAAOhH,KAAKiH,EAAEkK,OAAOS,EAAIzQ,EAAG0Q,IAG9B0H,EAAGvT,UAAU2U,oBAAsB,SAAS1c,EAAGqc,EAAaM,EAAGlX,GAE7D,GAAkC,QADlC4W,EAAc,IAAIvZ,EAAUuZ,EAAa5W,IACzBxC,cACd,OAAOoZ,EAAYpZ,cAErB,IAAK,IAAIvH,EAAI,EAAGA,EAAI,EAAGA,IAAK,CAC1B,IAAIkhB,EACJ,IACEA,EAAS7a,KAAK8B,cAAc7D,EAAGqc,EAAa3gB,GAC5C,MAAOsE,GACP,SAGF,GAAI4c,EAAOxQ,GAAGuQ,GACZ,OAAOjhB,EAEX,MAAM,IAAIiC,MAAM,yCAGlB,IAAIkf,EAAa5Y,YAA+BG,EAAQE,GAGxD,IAAIwY,EAAWxY,EAEfwY,EAASC,QAAsC,QAC/CD,EAAS1X,MAAQS,EACjBiX,EAAS1B,KAAyC,WAAc,MAAM,IAAIzd,MAAM,gBAChFmf,EAASjT,MAAQgN,EACjBiG,EAAS7F,OAASD,EAGlB8F,EAASxD,GAAKA,EACdwD,EAASE,MAAmD,QAGxDC,EAAOJ,EAAWvD,K,wDC16Ef,IAAI4D,EAAX,kCACA,SAAWA,GACPA,EAA2B,OAAI,SAC/BA,EAA2B,OAAI,SAFnC,CAGGA,IAAuBA,EAAqB,M,oNCJxC,MCMDC,EAAa,IAAIC,OAAO,mBACxBC,EAAc,IAAID,OAAO,qBACzBE,EAAa,IAAIF,OAAO,wBAIxBnjB,EAAS,IAAI,IDZI,kBCavB,SAASsjB,EAAMlV,EAAMvK,EAAO6H,GACxB,OAAQ0C,GACJ,IAAK,UACD,OAAI1C,EACO,YAAQ7H,EAAO,IAEnB,YAASA,GACpB,IAAK,SACD,OAAO,YAAYA,GACvB,IAAK,QACD,OAAO,YAASA,GACpB,IAAK,OAED,OADAA,EAASA,EAAQ,OAAS,OACtB6H,EACO,YAAQ7H,EAAO,IAEnB,YAASA,GAExB,IAAI6C,EAAQ0H,EAAK1H,MAAM0c,GACvB,GAAI1c,EAAO,CAEP,IAAI6c,EAAOte,SAASyB,EAAM,IAAM,OAQhC,OAPKA,EAAM,IAAMtC,OAAOmf,KAAU7c,EAAM,IAAQ6c,EAAO,GAAM,GAAe,IAATA,GAAcA,EAAO,MACpFvjB,EAAOiC,mBAAmB,sBAAuB,OAAQmM,GAEzD1C,IACA6X,EAAO,KAEX1f,EAAQ,IAAU2f,KAAK3f,GAAO4f,OAAOF,GAC9B,YAAQ1f,EAAO0f,EAAO,GAGjC,GADA7c,EAAQ0H,EAAK1H,MAAMwc,GACfxc,EAAO,CACP,MAAM6c,EAAOte,SAASyB,EAAM,IAO5B,OANItC,OAAOmf,KAAU7c,EAAM,IAAe,IAAT6c,GAAcA,EAAO,KAClDvjB,EAAOiC,mBAAmB,qBAAsB,OAAQmM,GAExD,YAASvK,GAAOwO,aAAekR,GAC/BvjB,EAAOiC,mBAAmB,qBAAqBmM,EAAQ,QAASvK,GAEhE6H,EACO,aAAU7H,EA7Cf,oEA6C8BG,UAAU,EAAG,KAE1CH,EAGX,GADA6C,EAAQ0H,EAAK1H,MAAM2c,GACf3c,GAAS+E,MAAMC,QAAQ7H,GAAQ,CAC/B,MAAM6f,EAAWhd,EAAM,GACTzB,SAASyB,EAAM,IAAMtC,OAAOP,EAAMlC,UACnCkC,EAAMlC,QACf3B,EAAOiC,mBAAmB,4BAA4BmM,EAAQ,QAASvK,GAE3E,MAAMrB,EAAS,GAIf,OAHAqB,EAAMuB,SAAQA,SAAUvB,GACpBrB,EAAOH,KAAKihB,EAAMI,EAAU7f,UAEzB,YAAOrB,GAElB,OAAOxC,EAAOiC,mBAAmB,eAAgB,OAAQmM,GAGtD,SAASuV,EAAKC,EAAO/c,GACpB+c,EAAMjiB,QAAUkF,EAAOlF,QACvB3B,EAAOiC,mBAAmB,qDAAsD,SAAU4E,GAE9F,MAAMgd,EAAQ,GAId,OAHAD,EAAMxe,SAAQA,SAAUgJ,EAAM2D,GAC1B8R,EAAMxhB,KAAKihB,EAAMlV,EAAMvH,EAAOkL,QAE3B,YAAQ,YAAO8R,IAEnB,SAASC,EAAUF,EAAO/c,GAC7B,OAAO,YAAc8c,EAAKC,EAAO/c,IAE9B,SAASxG,EAAOujB,EAAO/c,GAC1B,OAAO,YAAW8c,EAAKC,EAAO/c","file":"js/chunk-vendors~4cd998c9.168d0145.js","sourcesContent":["export const version = \"sha2/5.6.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport hash from \"hash.js\";\n//const _ripemd160 = _hash.ripemd160;\nimport { arrayify } from \"@ethersproject/bytes\";\nimport { SupportedAlgorithm } from \"./types\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nexport function ripemd160(data) {\n    return \"0x\" + (hash.ripemd160().update(arrayify(data)).digest(\"hex\"));\n}\nexport function sha256(data) {\n    return \"0x\" + (hash.sha256().update(arrayify(data)).digest(\"hex\"));\n}\nexport function sha512(data) {\n    return \"0x\" + (hash.sha512().update(arrayify(data)).digest(\"hex\"));\n}\nexport function computeHmac(algorithm, key, data) {\n    if (!SupportedAlgorithm[algorithm]) {\n        logger.throwError(\"unsupported algorithm \" + algorithm, Logger.errors.UNSUPPORTED_OPERATION, {\n            operation: \"hmac\",\n            algorithm: algorithm\n        });\n    }\n    return \"0x\" + hash.hmac(hash[algorithm], arrayify(key)).update(arrayify(data)).digest(\"hex\");\n}\n//# sourceMappingURL=sha2.js.map","export const version = \"strings/5.6.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { arrayify } from \"@ethersproject/bytes\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n///////////////////////////////\nexport var UnicodeNormalizationForm;\n(function (UnicodeNormalizationForm) {\n    UnicodeNormalizationForm[\"current\"] = \"\";\n    UnicodeNormalizationForm[\"NFC\"] = \"NFC\";\n    UnicodeNormalizationForm[\"NFD\"] = \"NFD\";\n    UnicodeNormalizationForm[\"NFKC\"] = \"NFKC\";\n    UnicodeNormalizationForm[\"NFKD\"] = \"NFKD\";\n})(UnicodeNormalizationForm || (UnicodeNormalizationForm = {}));\n;\nexport var Utf8ErrorReason;\n(function (Utf8ErrorReason) {\n    // A continuation byte was present where there was nothing to continue\n    // - offset = the index the codepoint began in\n    Utf8ErrorReason[\"UNEXPECTED_CONTINUE\"] = \"unexpected continuation byte\";\n    // An invalid (non-continuation) byte to start a UTF-8 codepoint was found\n    // - offset = the index the codepoint began in\n    Utf8ErrorReason[\"BAD_PREFIX\"] = \"bad codepoint prefix\";\n    // The string is too short to process the expected codepoint\n    // - offset = the index the codepoint began in\n    Utf8ErrorReason[\"OVERRUN\"] = \"string overrun\";\n    // A missing continuation byte was expected but not found\n    // - offset = the index the continuation byte was expected at\n    Utf8ErrorReason[\"MISSING_CONTINUE\"] = \"missing continuation byte\";\n    // The computed code point is outside the range for UTF-8\n    // - offset       = start of this codepoint\n    // - badCodepoint = the computed codepoint; outside the UTF-8 range\n    Utf8ErrorReason[\"OUT_OF_RANGE\"] = \"out of UTF-8 range\";\n    // UTF-8 strings may not contain UTF-16 surrogate pairs\n    // - offset       = start of this codepoint\n    // - badCodepoint = the computed codepoint; inside the UTF-16 surrogate range\n    Utf8ErrorReason[\"UTF16_SURROGATE\"] = \"UTF-16 surrogate\";\n    // The string is an overlong representation\n    // - offset       = start of this codepoint\n    // - badCodepoint = the computed codepoint; already bounds checked\n    Utf8ErrorReason[\"OVERLONG\"] = \"overlong representation\";\n})(Utf8ErrorReason || (Utf8ErrorReason = {}));\n;\nfunction errorFunc(reason, offset, bytes, output, badCodepoint) {\n    return logger.throwArgumentError(`invalid codepoint at offset ${offset}; ${reason}`, \"bytes\", bytes);\n}\nfunction ignoreFunc(reason, offset, bytes, output, badCodepoint) {\n    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes\n    if (reason === Utf8ErrorReason.BAD_PREFIX || reason === Utf8ErrorReason.UNEXPECTED_CONTINUE) {\n        let i = 0;\n        for (let o = offset + 1; o < bytes.length; o++) {\n            if (bytes[o] >> 6 !== 0x02) {\n                break;\n            }\n            i++;\n        }\n        return i;\n    }\n    // This byte runs us past the end of the string, so just jump to the end\n    // (but the first byte was read already read and therefore skipped)\n    if (reason === Utf8ErrorReason.OVERRUN) {\n        return bytes.length - offset - 1;\n    }\n    // Nothing to skip\n    return 0;\n}\nfunction replaceFunc(reason, offset, bytes, output, badCodepoint) {\n    // Overlong representations are otherwise \"valid\" code points; just non-deistingtished\n    if (reason === Utf8ErrorReason.OVERLONG) {\n        output.push(badCodepoint);\n        return 0;\n    }\n    // Put the replacement character into the output\n    output.push(0xfffd);\n    // Otherwise, process as if ignoring errors\n    return ignoreFunc(reason, offset, bytes, output, badCodepoint);\n}\n// Common error handing strategies\nexport const Utf8ErrorFuncs = Object.freeze({\n    error: errorFunc,\n    ignore: ignoreFunc,\n    replace: replaceFunc\n});\n// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499\nfunction getUtf8CodePoints(bytes, onError) {\n    if (onError == null) {\n        onError = Utf8ErrorFuncs.error;\n    }\n    bytes = arrayify(bytes);\n    const result = [];\n    let i = 0;\n    // Invalid bytes are ignored\n    while (i < bytes.length) {\n        const c = bytes[i++];\n        // 0xxx xxxx\n        if (c >> 7 === 0) {\n            result.push(c);\n            continue;\n        }\n        // Multibyte; how many bytes left for this character?\n        let extraLength = null;\n        let overlongMask = null;\n        // 110x xxxx 10xx xxxx\n        if ((c & 0xe0) === 0xc0) {\n            extraLength = 1;\n            overlongMask = 0x7f;\n            // 1110 xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf0) === 0xe0) {\n            extraLength = 2;\n            overlongMask = 0x7ff;\n            // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf8) === 0xf0) {\n            extraLength = 3;\n            overlongMask = 0xffff;\n        }\n        else {\n            if ((c & 0xc0) === 0x80) {\n                i += onError(Utf8ErrorReason.UNEXPECTED_CONTINUE, i - 1, bytes, result);\n            }\n            else {\n                i += onError(Utf8ErrorReason.BAD_PREFIX, i - 1, bytes, result);\n            }\n            continue;\n        }\n        // Do we have enough bytes in our data?\n        if (i - 1 + extraLength >= bytes.length) {\n            i += onError(Utf8ErrorReason.OVERRUN, i - 1, bytes, result);\n            continue;\n        }\n        // Remove the length prefix from the char\n        let res = c & ((1 << (8 - extraLength - 1)) - 1);\n        for (let j = 0; j < extraLength; j++) {\n            let nextChar = bytes[i];\n            // Invalid continuation byte\n            if ((nextChar & 0xc0) != 0x80) {\n                i += onError(Utf8ErrorReason.MISSING_CONTINUE, i, bytes, result);\n                res = null;\n                break;\n            }\n            ;\n            res = (res << 6) | (nextChar & 0x3f);\n            i++;\n        }\n        // See above loop for invalid continuation byte\n        if (res === null) {\n            continue;\n        }\n        // Maximum code point\n        if (res > 0x10ffff) {\n            i += onError(Utf8ErrorReason.OUT_OF_RANGE, i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Reserved for UTF-16 surrogate halves\n        if (res >= 0xd800 && res <= 0xdfff) {\n            i += onError(Utf8ErrorReason.UTF16_SURROGATE, i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Check for overlong sequences (more bytes than needed)\n        if (res <= overlongMask) {\n            i += onError(Utf8ErrorReason.OVERLONG, i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        result.push(res);\n    }\n    return result;\n}\n// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array\nexport function toUtf8Bytes(str, form = UnicodeNormalizationForm.current) {\n    if (form != UnicodeNormalizationForm.current) {\n        logger.checkNormalize();\n        str = str.normalize(form);\n    }\n    let result = [];\n    for (let i = 0; i < str.length; i++) {\n        const c = str.charCodeAt(i);\n        if (c < 0x80) {\n            result.push(c);\n        }\n        else if (c < 0x800) {\n            result.push((c >> 6) | 0xc0);\n            result.push((c & 0x3f) | 0x80);\n        }\n        else if ((c & 0xfc00) == 0xd800) {\n            i++;\n            const c2 = str.charCodeAt(i);\n            if (i >= str.length || (c2 & 0xfc00) !== 0xdc00) {\n                throw new Error(\"invalid utf-8 string\");\n            }\n            // Surrogate Pair\n            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);\n            result.push((pair >> 18) | 0xf0);\n            result.push(((pair >> 12) & 0x3f) | 0x80);\n            result.push(((pair >> 6) & 0x3f) | 0x80);\n            result.push((pair & 0x3f) | 0x80);\n        }\n        else {\n            result.push((c >> 12) | 0xe0);\n            result.push(((c >> 6) & 0x3f) | 0x80);\n            result.push((c & 0x3f) | 0x80);\n        }\n    }\n    return arrayify(result);\n}\n;\nfunction escapeChar(value) {\n    const hex = (\"0000\" + value.toString(16));\n    return \"\\\\u\" + hex.substring(hex.length - 4);\n}\nexport function _toEscapedUtf8String(bytes, onError) {\n    return '\"' + getUtf8CodePoints(bytes, onError).map((codePoint) => {\n        if (codePoint < 256) {\n            switch (codePoint) {\n                case 8: return \"\\\\b\";\n                case 9: return \"\\\\t\";\n                case 10: return \"\\\\n\";\n                case 13: return \"\\\\r\";\n                case 34: return \"\\\\\\\"\";\n                case 92: return \"\\\\\\\\\";\n            }\n            if (codePoint >= 32 && codePoint < 127) {\n                return String.fromCharCode(codePoint);\n            }\n        }\n        if (codePoint <= 0xffff) {\n            return escapeChar(codePoint);\n        }\n        codePoint -= 0x10000;\n        return escapeChar(((codePoint >> 10) & 0x3ff) + 0xd800) + escapeChar((codePoint & 0x3ff) + 0xdc00);\n    }).join(\"\") + '\"';\n}\nexport function _toUtf8String(codePoints) {\n    return codePoints.map((codePoint) => {\n        if (codePoint <= 0xffff) {\n            return String.fromCharCode(codePoint);\n        }\n        codePoint -= 0x10000;\n        return String.fromCharCode((((codePoint >> 10) & 0x3ff) + 0xd800), ((codePoint & 0x3ff) + 0xdc00));\n    }).join(\"\");\n}\nexport function toUtf8String(bytes, onError) {\n    return _toUtf8String(getUtf8CodePoints(bytes, onError));\n}\nexport function toUtf8CodePoints(str, form = UnicodeNormalizationForm.current) {\n    return getUtf8CodePoints(toUtf8Bytes(str, form));\n}\n//# sourceMappingURL=utf8.js.map","\"use strict\";\nimport { HashZero } from \"@ethersproject/constants\";\nimport { arrayify, concat, hexlify } from \"@ethersproject/bytes\";\nimport { toUtf8Bytes, toUtf8String } from \"./utf8\";\nexport function formatBytes32String(text) {\n    // Get the bytes\n    const bytes = toUtf8Bytes(text);\n    // Check we have room for null-termination\n    if (bytes.length > 31) {\n        throw new Error(\"bytes32 string must be less than 32 bytes\");\n    }\n    // Zero-pad (implicitly null-terminates)\n    return hexlify(concat([bytes, HashZero]).slice(0, 32));\n}\nexport function parseBytes32String(bytes) {\n    const data = arrayify(bytes);\n    // Must be 32 bytes with a null-termination\n    if (data.length !== 32) {\n        throw new Error(\"invalid bytes32 - not 32 bytes long\");\n    }\n    if (data[31] !== 0) {\n        throw new Error(\"invalid bytes32 string - no null terminator\");\n    }\n    // Find the null termination\n    let length = 31;\n    while (data[length - 1] === 0) {\n        length--;\n    }\n    // Determine the string value\n    return toUtf8String(data.slice(0, length));\n}\n//# sourceMappingURL=bytes32.js.map","\"use strict\";\nimport { toUtf8CodePoints, _toUtf8String, UnicodeNormalizationForm } from \"./utf8\";\nfunction bytes2(data) {\n    if ((data.length % 4) !== 0) {\n        throw new Error(\"bad data\");\n    }\n    let result = [];\n    for (let i = 0; i < data.length; i += 4) {\n        result.push(parseInt(data.substring(i, i + 4), 16));\n    }\n    return result;\n}\nfunction createTable(data, func) {\n    if (!func) {\n        func = function (value) { return [parseInt(value, 16)]; };\n    }\n    let lo = 0;\n    let result = {};\n    data.split(\",\").forEach((pair) => {\n        let comps = pair.split(\":\");\n        lo += parseInt(comps[0], 16);\n        result[lo] = func(comps[1]);\n    });\n    return result;\n}\nfunction createRangeTable(data) {\n    let hi = 0;\n    return data.split(\",\").map((v) => {\n        let comps = v.split(\"-\");\n        if (comps.length === 1) {\n            comps[1] = \"0\";\n        }\n        else if (comps[1] === \"\") {\n            comps[1] = \"1\";\n        }\n        let lo = hi + parseInt(comps[0], 16);\n        hi = parseInt(comps[1], 16);\n        return { l: lo, h: hi };\n    });\n}\nfunction matchMap(value, ranges) {\n    let lo = 0;\n    for (let i = 0; i < ranges.length; i++) {\n        let range = ranges[i];\n        lo += range.l;\n        if (value >= lo && value <= lo + range.h && ((value - lo) % (range.d || 1)) === 0) {\n            if (range.e && range.e.indexOf(value - lo) !== -1) {\n                continue;\n            }\n            return range;\n        }\n    }\n    return null;\n}\nconst Table_A_1_ranges = createRangeTable(\"221,13-1b,5f-,40-10,51-f,11-3,3-3,2-2,2-4,8,2,15,2d,28-8,88,48,27-,3-5,11-20,27-,8,28,3-5,12,18,b-a,1c-4,6-16,2-d,2-2,2,1b-4,17-9,8f-,10,f,1f-2,1c-34,33-14e,4,36-,13-,6-2,1a-f,4,9-,3-,17,8,2-2,5-,2,8-,3-,4-8,2-3,3,6-,16-6,2-,7-3,3-,17,8,3,3,3-,2,6-3,3-,4-a,5,2-6,10-b,4,8,2,4,17,8,3,6-,b,4,4-,2-e,2-4,b-10,4,9-,3-,17,8,3-,5-,9-2,3-,4-7,3-3,3,4-3,c-10,3,7-2,4,5-2,3,2,3-2,3-2,4-2,9,4-3,6-2,4,5-8,2-e,d-d,4,9,4,18,b,6-3,8,4,5-6,3-8,3-3,b-11,3,9,4,18,b,6-3,8,4,5-6,3-6,2,3-3,b-11,3,9,4,18,11-3,7-,4,5-8,2-7,3-3,b-11,3,13-2,19,a,2-,8-2,2-3,7,2,9-11,4-b,3b-3,1e-24,3,2-,3,2-,2-5,5,8,4,2,2-,3,e,4-,6,2,7-,b-,3-21,49,23-5,1c-3,9,25,10-,2-2f,23,6,3,8-2,5-5,1b-45,27-9,2a-,2-3,5b-4,45-4,53-5,8,40,2,5-,8,2,5-,28,2,5-,20,2,5-,8,2,5-,8,8,18,20,2,5-,8,28,14-5,1d-22,56-b,277-8,1e-2,52-e,e,8-a,18-8,15-b,e,4,3-b,5e-2,b-15,10,b-5,59-7,2b-555,9d-3,5b-5,17-,7-,27-,7-,9,2,2,2,20-,36,10,f-,7,14-,4,a,54-3,2-6,6-5,9-,1c-10,13-1d,1c-14,3c-,10-6,32-b,240-30,28-18,c-14,a0,115-,3,66-,b-76,5,5-,1d,24,2,5-2,2,8-,35-2,19,f-10,1d-3,311-37f,1b,5a-b,d7-19,d-3,41,57-,68-4,29-3,5f,29-37,2e-2,25-c,2c-2,4e-3,30,78-3,64-,20,19b7-49,51a7-59,48e-2,38-738,2ba5-5b,222f-,3c-94,8-b,6-4,1b,6,2,3,3,6d-20,16e-f,41-,37-7,2e-2,11-f,5-b,18-,b,14,5-3,6,88-,2,bf-2,7-,7-,7-,4-2,8,8-9,8-2ff,20,5-b,1c-b4,27-,27-cbb1,f7-9,28-2,b5-221,56,48,3-,2-,3-,5,d,2,5,3,42,5-,9,8,1d,5,6,2-2,8,153-3,123-3,33-27fd,a6da-5128,21f-5df,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3,2-1d,61-ff7d\");\n// @TODO: Make this relative...\nconst Table_B_1_flags = \"ad,34f,1806,180b,180c,180d,200b,200c,200d,2060,feff\".split(\",\").map((v) => parseInt(v, 16));\nconst Table_B_2_ranges = [\n    { h: 25, s: 32, l: 65 },\n    { h: 30, s: 32, e: [23], l: 127 },\n    { h: 54, s: 1, e: [48], l: 64, d: 2 },\n    { h: 14, s: 1, l: 57, d: 2 },\n    { h: 44, s: 1, l: 17, d: 2 },\n    { h: 10, s: 1, e: [2, 6, 8], l: 61, d: 2 },\n    { h: 16, s: 1, l: 68, d: 2 },\n    { h: 84, s: 1, e: [18, 24, 66], l: 19, d: 2 },\n    { h: 26, s: 32, e: [17], l: 435 },\n    { h: 22, s: 1, l: 71, d: 2 },\n    { h: 15, s: 80, l: 40 },\n    { h: 31, s: 32, l: 16 },\n    { h: 32, s: 1, l: 80, d: 2 },\n    { h: 52, s: 1, l: 42, d: 2 },\n    { h: 12, s: 1, l: 55, d: 2 },\n    { h: 40, s: 1, e: [38], l: 15, d: 2 },\n    { h: 14, s: 1, l: 48, d: 2 },\n    { h: 37, s: 48, l: 49 },\n    { h: 148, s: 1, l: 6351, d: 2 },\n    { h: 88, s: 1, l: 160, d: 2 },\n    { h: 15, s: 16, l: 704 },\n    { h: 25, s: 26, l: 854 },\n    { h: 25, s: 32, l: 55915 },\n    { h: 37, s: 40, l: 1247 },\n    { h: 25, s: -119711, l: 53248 },\n    { h: 25, s: -119763, l: 52 },\n    { h: 25, s: -119815, l: 52 },\n    { h: 25, s: -119867, e: [1, 4, 5, 7, 8, 11, 12, 17], l: 52 },\n    { h: 25, s: -119919, l: 52 },\n    { h: 24, s: -119971, e: [2, 7, 8, 17], l: 52 },\n    { h: 24, s: -120023, e: [2, 7, 13, 15, 16, 17], l: 52 },\n    { h: 25, s: -120075, l: 52 },\n    { h: 25, s: -120127, l: 52 },\n    { h: 25, s: -120179, l: 52 },\n    { h: 25, s: -120231, l: 52 },\n    { h: 25, s: -120283, l: 52 },\n    { h: 25, s: -120335, l: 52 },\n    { h: 24, s: -119543, e: [17], l: 56 },\n    { h: 24, s: -119601, e: [17], l: 58 },\n    { h: 24, s: -119659, e: [17], l: 58 },\n    { h: 24, s: -119717, e: [17], l: 58 },\n    { h: 24, s: -119775, e: [17], l: 58 }\n];\nconst Table_B_2_lut_abs = createTable(\"b5:3bc,c3:ff,7:73,2:253,5:254,3:256,1:257,5:259,1:25b,3:260,1:263,2:269,1:268,5:26f,1:272,2:275,7:280,3:283,5:288,3:28a,1:28b,5:292,3f:195,1:1bf,29:19e,125:3b9,8b:3b2,1:3b8,1:3c5,3:3c6,1:3c0,1a:3ba,1:3c1,1:3c3,2:3b8,1:3b5,1bc9:3b9,1c:1f76,1:1f77,f:1f7a,1:1f7b,d:1f78,1:1f79,1:1f7c,1:1f7d,107:63,5:25b,4:68,1:68,1:68,3:69,1:69,1:6c,3:6e,4:70,1:71,1:72,1:72,1:72,7:7a,2:3c9,2:7a,2:6b,1:e5,1:62,1:63,3:65,1:66,2:6d,b:3b3,1:3c0,6:64,1b574:3b8,1a:3c3,20:3b8,1a:3c3,20:3b8,1a:3c3,20:3b8,1a:3c3,20:3b8,1a:3c3\");\nconst Table_B_2_lut_rel = createTable(\"179:1,2:1,2:1,5:1,2:1,a:4f,a:1,8:1,2:1,2:1,3:1,5:1,3:1,4:1,2:1,3:1,4:1,8:2,1:1,2:2,1:1,2:2,27:2,195:26,2:25,1:25,1:25,2:40,2:3f,1:3f,33:1,11:-6,1:-9,1ac7:-3a,6d:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,9:-8,1:-8,1:-8,1:-8,1:-8,1:-8,b:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,9:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,9:-8,1:-8,1:-8,1:-8,1:-8,1:-8,c:-8,2:-8,2:-8,2:-8,9:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,49:-8,1:-8,1:-4a,1:-4a,d:-56,1:-56,1:-56,1:-56,d:-8,1:-8,f:-8,1:-8,3:-7\");\nconst Table_B_2_complex = createTable(\"df:00730073,51:00690307,19:02BC006E,a7:006A030C,18a:002003B9,16:03B903080301,20:03C503080301,1d7:05650582,190f:00680331,1:00740308,1:0077030A,1:0079030A,1:006102BE,b6:03C50313,2:03C503130300,2:03C503130301,2:03C503130342,2a:1F0003B9,1:1F0103B9,1:1F0203B9,1:1F0303B9,1:1F0403B9,1:1F0503B9,1:1F0603B9,1:1F0703B9,1:1F0003B9,1:1F0103B9,1:1F0203B9,1:1F0303B9,1:1F0403B9,1:1F0503B9,1:1F0603B9,1:1F0703B9,1:1F2003B9,1:1F2103B9,1:1F2203B9,1:1F2303B9,1:1F2403B9,1:1F2503B9,1:1F2603B9,1:1F2703B9,1:1F2003B9,1:1F2103B9,1:1F2203B9,1:1F2303B9,1:1F2403B9,1:1F2503B9,1:1F2603B9,1:1F2703B9,1:1F6003B9,1:1F6103B9,1:1F6203B9,1:1F6303B9,1:1F6403B9,1:1F6503B9,1:1F6603B9,1:1F6703B9,1:1F6003B9,1:1F6103B9,1:1F6203B9,1:1F6303B9,1:1F6403B9,1:1F6503B9,1:1F6603B9,1:1F6703B9,3:1F7003B9,1:03B103B9,1:03AC03B9,2:03B10342,1:03B1034203B9,5:03B103B9,6:1F7403B9,1:03B703B9,1:03AE03B9,2:03B70342,1:03B7034203B9,5:03B703B9,6:03B903080300,1:03B903080301,3:03B90342,1:03B903080342,b:03C503080300,1:03C503080301,1:03C10313,2:03C50342,1:03C503080342,b:1F7C03B9,1:03C903B9,1:03CE03B9,2:03C90342,1:03C9034203B9,5:03C903B9,ac:00720073,5b:00B00063,6:00B00066,d:006E006F,a:0073006D,1:00740065006C,1:0074006D,124f:006800700061,2:00610075,2:006F0076,b:00700061,1:006E0061,1:03BC0061,1:006D0061,1:006B0061,1:006B0062,1:006D0062,1:00670062,3:00700066,1:006E0066,1:03BC0066,4:0068007A,1:006B0068007A,1:006D0068007A,1:00670068007A,1:00740068007A,15:00700061,1:006B00700061,1:006D00700061,1:006700700061,8:00700076,1:006E0076,1:03BC0076,1:006D0076,1:006B0076,1:006D0076,1:00700077,1:006E0077,1:03BC0077,1:006D0077,1:006B0077,1:006D0077,1:006B03C9,1:006D03C9,2:00620071,3:00632215006B0067,1:0063006F002E,1:00640062,1:00670079,2:00680070,2:006B006B,1:006B006D,9:00700068,2:00700070006D,1:00700072,2:00730076,1:00770062,c723:00660066,1:00660069,1:0066006C,1:006600660069,1:00660066006C,1:00730074,1:00730074,d:05740576,1:05740565,1:0574056B,1:057E0576,1:0574056D\", bytes2);\nconst Table_C_ranges = createRangeTable(\"80-20,2a0-,39c,32,f71,18e,7f2-f,19-7,30-4,7-5,f81-b,5,a800-20ff,4d1-1f,110,fa-6,d174-7,2e84-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,2,1f-5f,ff7f-20001\");\nfunction flatten(values) {\n    return values.reduce((accum, value) => {\n        value.forEach((value) => { accum.push(value); });\n        return accum;\n    }, []);\n}\nexport function _nameprepTableA1(codepoint) {\n    return !!matchMap(codepoint, Table_A_1_ranges);\n}\nexport function _nameprepTableB2(codepoint) {\n    let range = matchMap(codepoint, Table_B_2_ranges);\n    if (range) {\n        return [codepoint + range.s];\n    }\n    let codes = Table_B_2_lut_abs[codepoint];\n    if (codes) {\n        return codes;\n    }\n    let shift = Table_B_2_lut_rel[codepoint];\n    if (shift) {\n        return [codepoint + shift[0]];\n    }\n    let complex = Table_B_2_complex[codepoint];\n    if (complex) {\n        return complex;\n    }\n    return null;\n}\nexport function _nameprepTableC(codepoint) {\n    return !!matchMap(codepoint, Table_C_ranges);\n}\nexport function nameprep(value) {\n    // This allows platforms with incomplete normalize to bypass\n    // it for very basic names which the built-in toLowerCase\n    // will certainly handle correctly\n    if (value.match(/^[a-z0-9-]*$/i) && value.length <= 59) {\n        return value.toLowerCase();\n    }\n    // Get the code points (keeping the current normalization)\n    let codes = toUtf8CodePoints(value);\n    codes = flatten(codes.map((code) => {\n        // Substitute Table B.1 (Maps to Nothing)\n        if (Table_B_1_flags.indexOf(code) >= 0) {\n            return [];\n        }\n        if (code >= 0xfe00 && code <= 0xfe0f) {\n            return [];\n        }\n        // Substitute Table B.2 (Case Folding)\n        let codesTableB2 = _nameprepTableB2(code);\n        if (codesTableB2) {\n            return codesTableB2;\n        }\n        // No Substitution\n        return [code];\n    }));\n    // Normalize using form KC\n    codes = toUtf8CodePoints(_toUtf8String(codes), UnicodeNormalizationForm.NFKC);\n    // Prohibit Tables C.1.2, C.2.2, C.3, C.4, C.5, C.6, C.7, C.8, C.9\n    codes.forEach((code) => {\n        if (_nameprepTableC(code)) {\n            throw new Error(\"STRINGPREP_CONTAINS_PROHIBITED\");\n        }\n    });\n    // Prohibit Unassigned Code Points (Table A.1)\n    codes.forEach((code) => {\n        if (_nameprepTableA1(code)) {\n            throw new Error(\"STRINGPREP_CONTAINS_UNASSIGNED\");\n        }\n    });\n    // IDNA extras\n    let name = _toUtf8String(codes);\n    // IDNA: 4.2.3.1\n    if (name.substring(0, 1) === \"-\" || name.substring(2, 4) === \"--\" || name.substring(name.length - 1) === \"-\") {\n        throw new Error(\"invalid hyphen\");\n    }\n    // IDNA: 4.2.4\n    if (name.length > 63) {\n        throw new Error(\"too long\");\n    }\n    return name;\n}\n//# sourceMappingURL=idna.js.map","export const version = \"signing-key/5.6.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { EC } from \"./elliptic\";\nimport { arrayify, hexlify, hexZeroPad, splitSignature } from \"@ethersproject/bytes\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nlet _curve = null;\nfunction getCurve() {\n    if (!_curve) {\n        _curve = new EC(\"secp256k1\");\n    }\n    return _curve;\n}\nexport class SigningKey {\n    constructor(privateKey) {\n        defineReadOnly(this, \"curve\", \"secp256k1\");\n        defineReadOnly(this, \"privateKey\", hexlify(privateKey));\n        const keyPair = getCurve().keyFromPrivate(arrayify(this.privateKey));\n        defineReadOnly(this, \"publicKey\", \"0x\" + keyPair.getPublic(false, \"hex\"));\n        defineReadOnly(this, \"compressedPublicKey\", \"0x\" + keyPair.getPublic(true, \"hex\"));\n        defineReadOnly(this, \"_isSigningKey\", true);\n    }\n    _addPoint(other) {\n        const p0 = getCurve().keyFromPublic(arrayify(this.publicKey));\n        const p1 = getCurve().keyFromPublic(arrayify(other));\n        return \"0x\" + p0.pub.add(p1.pub).encodeCompressed(\"hex\");\n    }\n    signDigest(digest) {\n        const keyPair = getCurve().keyFromPrivate(arrayify(this.privateKey));\n        const digestBytes = arrayify(digest);\n        if (digestBytes.length !== 32) {\n            logger.throwArgumentError(\"bad digest length\", \"digest\", digest);\n        }\n        const signature = keyPair.sign(digestBytes, { canonical: true });\n        return splitSignature({\n            recoveryParam: signature.recoveryParam,\n            r: hexZeroPad(\"0x\" + signature.r.toString(16), 32),\n            s: hexZeroPad(\"0x\" + signature.s.toString(16), 32),\n        });\n    }\n    computeSharedSecret(otherKey) {\n        const keyPair = getCurve().keyFromPrivate(arrayify(this.privateKey));\n        const otherKeyPair = getCurve().keyFromPublic(arrayify(computePublicKey(otherKey)));\n        return hexZeroPad(\"0x\" + keyPair.derive(otherKeyPair.getPublic()).toString(16), 32);\n    }\n    static isSigningKey(value) {\n        return !!(value && value._isSigningKey);\n    }\n}\nexport function recoverPublicKey(digest, signature) {\n    const sig = splitSignature(signature);\n    const rs = { r: arrayify(sig.r), s: arrayify(sig.s) };\n    return \"0x\" + getCurve().recoverPubKey(arrayify(digest), rs, sig.recoveryParam).encode(\"hex\", false);\n}\nexport function computePublicKey(key, compressed) {\n    const bytes = arrayify(key);\n    if (bytes.length === 32) {\n        const signingKey = new SigningKey(bytes);\n        if (compressed) {\n            return \"0x\" + getCurve().keyFromPrivate(bytes).getPublic(true, \"hex\");\n        }\n        return signingKey.publicKey;\n    }\n    else if (bytes.length === 33) {\n        if (compressed) {\n            return hexlify(bytes);\n        }\n        return \"0x\" + getCurve().keyFromPublic(bytes).getPublic(false, \"hex\");\n    }\n    else if (bytes.length === 65) {\n        if (!compressed) {\n            return hexlify(bytes);\n        }\n        return \"0x\" + getCurve().keyFromPublic(bytes).getPublic(true, \"hex\");\n    }\n    return logger.throwArgumentError(\"invalid public or private key\", \"key\", \"[REDACTED]\");\n}\n//# sourceMappingURL=index.js.map","import BN from 'bn.js';\nimport hash from 'hash.js';\n\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\nfunction getDefaultExportFromCjs (x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n}\n\nfunction createCommonjsModule(fn, basedir, module) {\n\treturn module = {\n\t\tpath: basedir,\n\t\texports: {},\n\t\trequire: function (path, base) {\n\t\t\treturn commonjsRequire(path, (base === undefined || base === null) ? module.path : base);\n\t\t}\n\t}, fn(module, module.exports), module.exports;\n}\n\nfunction getDefaultExportFromNamespaceIfPresent (n) {\n\treturn n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;\n}\n\nfunction getDefaultExportFromNamespaceIfNotNamed (n) {\n\treturn n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;\n}\n\nfunction getAugmentedNamespace(n) {\n\tif (n.__esModule) return n;\n\tvar a = Object.defineProperty({}, '__esModule', {value: true});\n\tObject.keys(n).forEach(function (k) {\n\t\tvar d = Object.getOwnPropertyDescriptor(n, k);\n\t\tObject.defineProperty(a, k, d.get ? d : {\n\t\t\tenumerable: true,\n\t\t\tget: function () {\n\t\t\t\treturn n[k];\n\t\t\t}\n\t\t});\n\t});\n\treturn a;\n}\n\nfunction commonjsRequire () {\n\tthrow new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');\n}\n\nvar minimalisticAssert = assert;\n\nfunction assert(val, msg) {\n  if (!val)\n    throw new Error(msg || 'Assertion failed');\n}\n\nassert.equal = function assertEqual(l, r, msg) {\n  if (l != r)\n    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));\n};\n\nvar utils_1 = createCommonjsModule(function (module, exports) {\n'use strict';\n\nvar utils = exports;\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg))\n    return msg.slice();\n  if (!msg)\n    return [];\n  var res = [];\n  if (typeof msg !== 'string') {\n    for (var i = 0; i < msg.length; i++)\n      res[i] = msg[i] | 0;\n    return res;\n  }\n  if (enc === 'hex') {\n    msg = msg.replace(/[^a-z0-9]+/ig, '');\n    if (msg.length % 2 !== 0)\n      msg = '0' + msg;\n    for (var i = 0; i < msg.length; i += 2)\n      res.push(parseInt(msg[i] + msg[i + 1], 16));\n  } else {\n    for (var i = 0; i < msg.length; i++) {\n      var c = msg.charCodeAt(i);\n      var hi = c >> 8;\n      var lo = c & 0xff;\n      if (hi)\n        res.push(hi, lo);\n      else\n        res.push(lo);\n    }\n  }\n  return res;\n}\nutils.toArray = toArray;\n\nfunction zero2(word) {\n  if (word.length === 1)\n    return '0' + word;\n  else\n    return word;\n}\nutils.zero2 = zero2;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++)\n    res += zero2(msg[i].toString(16));\n  return res;\n}\nutils.toHex = toHex;\n\nutils.encode = function encode(arr, enc) {\n  if (enc === 'hex')\n    return toHex(arr);\n  else\n    return arr;\n};\n});\n\nvar utils_1$1 = createCommonjsModule(function (module, exports) {\n'use strict';\n\nvar utils = exports;\n\n\n\n\nutils.assert = minimalisticAssert;\nutils.toArray = utils_1.toArray;\nutils.zero2 = utils_1.zero2;\nutils.toHex = utils_1.toHex;\nutils.encode = utils_1.encode;\n\n// Represent num in a w-NAF form\nfunction getNAF(num, w, bits) {\n  var naf = new Array(Math.max(num.bitLength(), bits) + 1);\n  naf.fill(0);\n\n  var ws = 1 << (w + 1);\n  var k = num.clone();\n\n  for (var i = 0; i < naf.length; i++) {\n    var z;\n    var mod = k.andln(ws - 1);\n    if (k.isOdd()) {\n      if (mod > (ws >> 1) - 1)\n        z = (ws >> 1) - mod;\n      else\n        z = mod;\n      k.isubn(z);\n    } else {\n      z = 0;\n    }\n\n    naf[i] = z;\n    k.iushrn(1);\n  }\n\n  return naf;\n}\nutils.getNAF = getNAF;\n\n// Represent k1, k2 in a Joint Sparse Form\nfunction getJSF(k1, k2) {\n  var jsf = [\n    [],\n    [],\n  ];\n\n  k1 = k1.clone();\n  k2 = k2.clone();\n  var d1 = 0;\n  var d2 = 0;\n  var m8;\n  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {\n    // First phase\n    var m14 = (k1.andln(3) + d1) & 3;\n    var m24 = (k2.andln(3) + d2) & 3;\n    if (m14 === 3)\n      m14 = -1;\n    if (m24 === 3)\n      m24 = -1;\n    var u1;\n    if ((m14 & 1) === 0) {\n      u1 = 0;\n    } else {\n      m8 = (k1.andln(7) + d1) & 7;\n      if ((m8 === 3 || m8 === 5) && m24 === 2)\n        u1 = -m14;\n      else\n        u1 = m14;\n    }\n    jsf[0].push(u1);\n\n    var u2;\n    if ((m24 & 1) === 0) {\n      u2 = 0;\n    } else {\n      m8 = (k2.andln(7) + d2) & 7;\n      if ((m8 === 3 || m8 === 5) && m14 === 2)\n        u2 = -m24;\n      else\n        u2 = m24;\n    }\n    jsf[1].push(u2);\n\n    // Second phase\n    if (2 * d1 === u1 + 1)\n      d1 = 1 - d1;\n    if (2 * d2 === u2 + 1)\n      d2 = 1 - d2;\n    k1.iushrn(1);\n    k2.iushrn(1);\n  }\n\n  return jsf;\n}\nutils.getJSF = getJSF;\n\nfunction cachedProperty(obj, name, computer) {\n  var key = '_' + name;\n  obj.prototype[name] = function cachedProperty() {\n    return this[key] !== undefined ? this[key] :\n      this[key] = computer.call(this);\n  };\n}\nutils.cachedProperty = cachedProperty;\n\nfunction parseBytes(bytes) {\n  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :\n    bytes;\n}\nutils.parseBytes = parseBytes;\n\nfunction intFromLE(bytes) {\n  return new BN(bytes, 'hex', 'le');\n}\nutils.intFromLE = intFromLE;\n});\n\n'use strict';\n\n\n\nvar getNAF = utils_1$1.getNAF;\nvar getJSF = utils_1$1.getJSF;\nvar assert$1 = utils_1$1.assert;\n\nfunction BaseCurve(type, conf) {\n  this.type = type;\n  this.p = new BN(conf.p, 16);\n\n  // Use Montgomery, when there is no fast reduction for the prime\n  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);\n\n  // Useful for many curves\n  this.zero = new BN(0).toRed(this.red);\n  this.one = new BN(1).toRed(this.red);\n  this.two = new BN(2).toRed(this.red);\n\n  // Curve configuration, optional\n  this.n = conf.n && new BN(conf.n, 16);\n  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);\n\n  // Temporary arrays\n  this._wnafT1 = new Array(4);\n  this._wnafT2 = new Array(4);\n  this._wnafT3 = new Array(4);\n  this._wnafT4 = new Array(4);\n\n  this._bitLength = this.n ? this.n.bitLength() : 0;\n\n  // Generalized Greg Maxwell's trick\n  var adjustCount = this.n && this.p.div(this.n);\n  if (!adjustCount || adjustCount.cmpn(100) > 0) {\n    this.redN = null;\n  } else {\n    this._maxwellTrick = true;\n    this.redN = this.n.toRed(this.red);\n  }\n}\nvar base = BaseCurve;\n\nBaseCurve.prototype.point = function point() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype.validate = function validate() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {\n  assert$1(p.precomputed);\n  var doubles = p._getDoubles();\n\n  var naf = getNAF(k, 1, this._bitLength);\n  var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);\n  I /= 3;\n\n  // Translate into more windowed form\n  var repr = [];\n  var j;\n  var nafW;\n  for (j = 0; j < naf.length; j += doubles.step) {\n    nafW = 0;\n    for (var l = j + doubles.step - 1; l >= j; l--)\n      nafW = (nafW << 1) + naf[l];\n    repr.push(nafW);\n  }\n\n  var a = this.jpoint(null, null, null);\n  var b = this.jpoint(null, null, null);\n  for (var i = I; i > 0; i--) {\n    for (j = 0; j < repr.length; j++) {\n      nafW = repr[j];\n      if (nafW === i)\n        b = b.mixedAdd(doubles.points[j]);\n      else if (nafW === -i)\n        b = b.mixedAdd(doubles.points[j].neg());\n    }\n    a = a.add(b);\n  }\n  return a.toP();\n};\n\nBaseCurve.prototype._wnafMul = function _wnafMul(p, k) {\n  var w = 4;\n\n  // Precompute window\n  var nafPoints = p._getNAFPoints(w);\n  w = nafPoints.wnd;\n  var wnd = nafPoints.points;\n\n  // Get NAF form\n  var naf = getNAF(k, w, this._bitLength);\n\n  // Add `this`*(N+1) for every w-NAF index\n  var acc = this.jpoint(null, null, null);\n  for (var i = naf.length - 1; i >= 0; i--) {\n    // Count zeroes\n    for (var l = 0; i >= 0 && naf[i] === 0; i--)\n      l++;\n    if (i >= 0)\n      l++;\n    acc = acc.dblp(l);\n\n    if (i < 0)\n      break;\n    var z = naf[i];\n    assert$1(z !== 0);\n    if (p.type === 'affine') {\n      // J +- P\n      if (z > 0)\n        acc = acc.mixedAdd(wnd[(z - 1) >> 1]);\n      else\n        acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());\n    } else {\n      // J +- J\n      if (z > 0)\n        acc = acc.add(wnd[(z - 1) >> 1]);\n      else\n        acc = acc.add(wnd[(-z - 1) >> 1].neg());\n    }\n  }\n  return p.type === 'affine' ? acc.toP() : acc;\n};\n\nBaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,\n  points,\n  coeffs,\n  len,\n  jacobianResult) {\n  var wndWidth = this._wnafT1;\n  var wnd = this._wnafT2;\n  var naf = this._wnafT3;\n\n  // Fill all arrays\n  var max = 0;\n  var i;\n  var j;\n  var p;\n  for (i = 0; i < len; i++) {\n    p = points[i];\n    var nafPoints = p._getNAFPoints(defW);\n    wndWidth[i] = nafPoints.wnd;\n    wnd[i] = nafPoints.points;\n  }\n\n  // Comb small window NAFs\n  for (i = len - 1; i >= 1; i -= 2) {\n    var a = i - 1;\n    var b = i;\n    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {\n      naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);\n      naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);\n      max = Math.max(naf[a].length, max);\n      max = Math.max(naf[b].length, max);\n      continue;\n    }\n\n    var comb = [\n      points[a], /* 1 */\n      null, /* 3 */\n      null, /* 5 */\n      points[b], /* 7 */\n    ];\n\n    // Try to avoid Projective points, if possible\n    if (points[a].y.cmp(points[b].y) === 0) {\n      comb[1] = points[a].add(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].add(points[b].neg());\n    } else {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    }\n\n    var index = [\n      -3, /* -1 -1 */\n      -1, /* -1 0 */\n      -5, /* -1 1 */\n      -7, /* 0 -1 */\n      0, /* 0 0 */\n      7, /* 0 1 */\n      5, /* 1 -1 */\n      1, /* 1 0 */\n      3,  /* 1 1 */\n    ];\n\n    var jsf = getJSF(coeffs[a], coeffs[b]);\n    max = Math.max(jsf[0].length, max);\n    naf[a] = new Array(max);\n    naf[b] = new Array(max);\n    for (j = 0; j < max; j++) {\n      var ja = jsf[0][j] | 0;\n      var jb = jsf[1][j] | 0;\n\n      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];\n      naf[b][j] = 0;\n      wnd[a] = comb;\n    }\n  }\n\n  var acc = this.jpoint(null, null, null);\n  var tmp = this._wnafT4;\n  for (i = max; i >= 0; i--) {\n    var k = 0;\n\n    while (i >= 0) {\n      var zero = true;\n      for (j = 0; j < len; j++) {\n        tmp[j] = naf[j][i] | 0;\n        if (tmp[j] !== 0)\n          zero = false;\n      }\n      if (!zero)\n        break;\n      k++;\n      i--;\n    }\n    if (i >= 0)\n      k++;\n    acc = acc.dblp(k);\n    if (i < 0)\n      break;\n\n    for (j = 0; j < len; j++) {\n      var z = tmp[j];\n      p;\n      if (z === 0)\n        continue;\n      else if (z > 0)\n        p = wnd[j][(z - 1) >> 1];\n      else if (z < 0)\n        p = wnd[j][(-z - 1) >> 1].neg();\n\n      if (p.type === 'affine')\n        acc = acc.mixedAdd(p);\n      else\n        acc = acc.add(p);\n    }\n  }\n  // Zeroify references\n  for (i = 0; i < len; i++)\n    wnd[i] = null;\n\n  if (jacobianResult)\n    return acc;\n  else\n    return acc.toP();\n};\n\nfunction BasePoint(curve, type) {\n  this.curve = curve;\n  this.type = type;\n  this.precomputed = null;\n}\nBaseCurve.BasePoint = BasePoint;\n\nBasePoint.prototype.eq = function eq(/*other*/) {\n  throw new Error('Not implemented');\n};\n\nBasePoint.prototype.validate = function validate() {\n  return this.curve.validate(this);\n};\n\nBaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n  bytes = utils_1$1.toArray(bytes, enc);\n\n  var len = this.p.byteLength();\n\n  // uncompressed, hybrid-odd, hybrid-even\n  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&\n      bytes.length - 1 === 2 * len) {\n    if (bytes[0] === 0x06)\n      assert$1(bytes[bytes.length - 1] % 2 === 0);\n    else if (bytes[0] === 0x07)\n      assert$1(bytes[bytes.length - 1] % 2 === 1);\n\n    var res =  this.point(bytes.slice(1, 1 + len),\n      bytes.slice(1 + len, 1 + 2 * len));\n\n    return res;\n  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&\n              bytes.length - 1 === len) {\n    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);\n  }\n  throw new Error('Unknown point format');\n};\n\nBasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {\n  return this.encode(enc, true);\n};\n\nBasePoint.prototype._encode = function _encode(compact) {\n  var len = this.curve.p.byteLength();\n  var x = this.getX().toArray('be', len);\n\n  if (compact)\n    return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x);\n\n  return [ 0x04 ].concat(x, this.getY().toArray('be', len));\n};\n\nBasePoint.prototype.encode = function encode(enc, compact) {\n  return utils_1$1.encode(this._encode(compact), enc);\n};\n\nBasePoint.prototype.precompute = function precompute(power) {\n  if (this.precomputed)\n    return this;\n\n  var precomputed = {\n    doubles: null,\n    naf: null,\n    beta: null,\n  };\n  precomputed.naf = this._getNAFPoints(8);\n  precomputed.doubles = this._getDoubles(4, power);\n  precomputed.beta = this._getBeta();\n  this.precomputed = precomputed;\n\n  return this;\n};\n\nBasePoint.prototype._hasDoubles = function _hasDoubles(k) {\n  if (!this.precomputed)\n    return false;\n\n  var doubles = this.precomputed.doubles;\n  if (!doubles)\n    return false;\n\n  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);\n};\n\nBasePoint.prototype._getDoubles = function _getDoubles(step, power) {\n  if (this.precomputed && this.precomputed.doubles)\n    return this.precomputed.doubles;\n\n  var doubles = [ this ];\n  var acc = this;\n  for (var i = 0; i < power; i += step) {\n    for (var j = 0; j < step; j++)\n      acc = acc.dbl();\n    doubles.push(acc);\n  }\n  return {\n    step: step,\n    points: doubles,\n  };\n};\n\nBasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {\n  if (this.precomputed && this.precomputed.naf)\n    return this.precomputed.naf;\n\n  var res = [ this ];\n  var max = (1 << wnd) - 1;\n  var dbl = max === 1 ? null : this.dbl();\n  for (var i = 1; i < max; i++)\n    res[i] = res[i - 1].add(dbl);\n  return {\n    wnd: wnd,\n    points: res,\n  };\n};\n\nBasePoint.prototype._getBeta = function _getBeta() {\n  return null;\n};\n\nBasePoint.prototype.dblp = function dblp(k) {\n  var r = this;\n  for (var i = 0; i < k; i++)\n    r = r.dbl();\n  return r;\n};\n\nvar inherits_browser = createCommonjsModule(function (module) {\nif (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor;\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      });\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor;\n      var TempCtor = function () {};\n      TempCtor.prototype = superCtor.prototype;\n      ctor.prototype = new TempCtor();\n      ctor.prototype.constructor = ctor;\n    }\n  };\n}\n});\n\n'use strict';\n\n\n\n\n\n\nvar assert$2 = utils_1$1.assert;\n\nfunction ShortCurve(conf) {\n  base.call(this, 'short', conf);\n\n  this.a = new BN(conf.a, 16).toRed(this.red);\n  this.b = new BN(conf.b, 16).toRed(this.red);\n  this.tinv = this.two.redInvm();\n\n  this.zeroA = this.a.fromRed().cmpn(0) === 0;\n  this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;\n\n  // If the curve is endomorphic, precalculate beta and lambda\n  this.endo = this._getEndomorphism(conf);\n  this._endoWnafT1 = new Array(4);\n  this._endoWnafT2 = new Array(4);\n}\ninherits_browser(ShortCurve, base);\nvar short_1 = ShortCurve;\n\nShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {\n  // No efficient endomorphism\n  if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)\n    return;\n\n  // Compute beta and lambda, that lambda * P = (beta * Px; Py)\n  var beta;\n  var lambda;\n  if (conf.beta) {\n    beta = new BN(conf.beta, 16).toRed(this.red);\n  } else {\n    var betas = this._getEndoRoots(this.p);\n    // Choose the smallest beta\n    beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];\n    beta = beta.toRed(this.red);\n  }\n  if (conf.lambda) {\n    lambda = new BN(conf.lambda, 16);\n  } else {\n    // Choose the lambda that is matching selected beta\n    var lambdas = this._getEndoRoots(this.n);\n    if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {\n      lambda = lambdas[0];\n    } else {\n      lambda = lambdas[1];\n      assert$2(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);\n    }\n  }\n\n  // Get basis vectors, used for balanced length-two representation\n  var basis;\n  if (conf.basis) {\n    basis = conf.basis.map(function(vec) {\n      return {\n        a: new BN(vec.a, 16),\n        b: new BN(vec.b, 16),\n      };\n    });\n  } else {\n    basis = this._getEndoBasis(lambda);\n  }\n\n  return {\n    beta: beta,\n    lambda: lambda,\n    basis: basis,\n  };\n};\n\nShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {\n  // Find roots of for x^2 + x + 1 in F\n  // Root = (-1 +- Sqrt(-3)) / 2\n  //\n  var red = num === this.p ? this.red : BN.mont(num);\n  var tinv = new BN(2).toRed(red).redInvm();\n  var ntinv = tinv.redNeg();\n\n  var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);\n\n  var l1 = ntinv.redAdd(s).fromRed();\n  var l2 = ntinv.redSub(s).fromRed();\n  return [ l1, l2 ];\n};\n\nShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {\n  // aprxSqrt >= sqrt(this.n)\n  var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));\n\n  // 3.74\n  // Run EGCD, until r(L + 1) < aprxSqrt\n  var u = lambda;\n  var v = this.n.clone();\n  var x1 = new BN(1);\n  var y1 = new BN(0);\n  var x2 = new BN(0);\n  var y2 = new BN(1);\n\n  // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)\n  var a0;\n  var b0;\n  // First vector\n  var a1;\n  var b1;\n  // Second vector\n  var a2;\n  var b2;\n\n  var prevR;\n  var i = 0;\n  var r;\n  var x;\n  while (u.cmpn(0) !== 0) {\n    var q = v.div(u);\n    r = v.sub(q.mul(u));\n    x = x2.sub(q.mul(x1));\n    var y = y2.sub(q.mul(y1));\n\n    if (!a1 && r.cmp(aprxSqrt) < 0) {\n      a0 = prevR.neg();\n      b0 = x1;\n      a1 = r.neg();\n      b1 = x;\n    } else if (a1 && ++i === 2) {\n      break;\n    }\n    prevR = r;\n\n    v = u;\n    u = r;\n    x2 = x1;\n    x1 = x;\n    y2 = y1;\n    y1 = y;\n  }\n  a2 = r.neg();\n  b2 = x;\n\n  var len1 = a1.sqr().add(b1.sqr());\n  var len2 = a2.sqr().add(b2.sqr());\n  if (len2.cmp(len1) >= 0) {\n    a2 = a0;\n    b2 = b0;\n  }\n\n  // Normalize signs\n  if (a1.negative) {\n    a1 = a1.neg();\n    b1 = b1.neg();\n  }\n  if (a2.negative) {\n    a2 = a2.neg();\n    b2 = b2.neg();\n  }\n\n  return [\n    { a: a1, b: b1 },\n    { a: a2, b: b2 },\n  ];\n};\n\nShortCurve.prototype._endoSplit = function _endoSplit(k) {\n  var basis = this.endo.basis;\n  var v1 = basis[0];\n  var v2 = basis[1];\n\n  var c1 = v2.b.mul(k).divRound(this.n);\n  var c2 = v1.b.neg().mul(k).divRound(this.n);\n\n  var p1 = c1.mul(v1.a);\n  var p2 = c2.mul(v2.a);\n  var q1 = c1.mul(v1.b);\n  var q2 = c2.mul(v2.b);\n\n  // Calculate answer\n  var k1 = k.sub(p1).sub(p2);\n  var k2 = q1.add(q2).neg();\n  return { k1: k1, k2: k2 };\n};\n\nShortCurve.prototype.pointFromX = function pointFromX(x, odd) {\n  x = new BN(x, 16);\n  if (!x.red)\n    x = x.toRed(this.red);\n\n  var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);\n  var y = y2.redSqrt();\n  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)\n    throw new Error('invalid point');\n\n  // XXX Is there any way to tell if the number is odd without converting it\n  // to non-red form?\n  var isOdd = y.fromRed().isOdd();\n  if (odd && !isOdd || !odd && isOdd)\n    y = y.redNeg();\n\n  return this.point(x, y);\n};\n\nShortCurve.prototype.validate = function validate(point) {\n  if (point.inf)\n    return true;\n\n  var x = point.x;\n  var y = point.y;\n\n  var ax = this.a.redMul(x);\n  var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);\n  return y.redSqr().redISub(rhs).cmpn(0) === 0;\n};\n\nShortCurve.prototype._endoWnafMulAdd =\n    function _endoWnafMulAdd(points, coeffs, jacobianResult) {\n      var npoints = this._endoWnafT1;\n      var ncoeffs = this._endoWnafT2;\n      for (var i = 0; i < points.length; i++) {\n        var split = this._endoSplit(coeffs[i]);\n        var p = points[i];\n        var beta = p._getBeta();\n\n        if (split.k1.negative) {\n          split.k1.ineg();\n          p = p.neg(true);\n        }\n        if (split.k2.negative) {\n          split.k2.ineg();\n          beta = beta.neg(true);\n        }\n\n        npoints[i * 2] = p;\n        npoints[i * 2 + 1] = beta;\n        ncoeffs[i * 2] = split.k1;\n        ncoeffs[i * 2 + 1] = split.k2;\n      }\n      var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);\n\n      // Clean-up references to points and coefficients\n      for (var j = 0; j < i * 2; j++) {\n        npoints[j] = null;\n        ncoeffs[j] = null;\n      }\n      return res;\n    };\n\nfunction Point(curve, x, y, isRed) {\n  base.BasePoint.call(this, curve, 'affine');\n  if (x === null && y === null) {\n    this.x = null;\n    this.y = null;\n    this.inf = true;\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    // Force redgomery representation when loading from JSON\n    if (isRed) {\n      this.x.forceRed(this.curve.red);\n      this.y.forceRed(this.curve.red);\n    }\n    if (!this.x.red)\n      this.x = this.x.toRed(this.curve.red);\n    if (!this.y.red)\n      this.y = this.y.toRed(this.curve.red);\n    this.inf = false;\n  }\n}\ninherits_browser(Point, base.BasePoint);\n\nShortCurve.prototype.point = function point(x, y, isRed) {\n  return new Point(this, x, y, isRed);\n};\n\nShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {\n  return Point.fromJSON(this, obj, red);\n};\n\nPoint.prototype._getBeta = function _getBeta() {\n  if (!this.curve.endo)\n    return;\n\n  var pre = this.precomputed;\n  if (pre && pre.beta)\n    return pre.beta;\n\n  var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);\n  if (pre) {\n    var curve = this.curve;\n    var endoMul = function(p) {\n      return curve.point(p.x.redMul(curve.endo.beta), p.y);\n    };\n    pre.beta = beta;\n    beta.precomputed = {\n      beta: null,\n      naf: pre.naf && {\n        wnd: pre.naf.wnd,\n        points: pre.naf.points.map(endoMul),\n      },\n      doubles: pre.doubles && {\n        step: pre.doubles.step,\n        points: pre.doubles.points.map(endoMul),\n      },\n    };\n  }\n  return beta;\n};\n\nPoint.prototype.toJSON = function toJSON() {\n  if (!this.precomputed)\n    return [ this.x, this.y ];\n\n  return [ this.x, this.y, this.precomputed && {\n    doubles: this.precomputed.doubles && {\n      step: this.precomputed.doubles.step,\n      points: this.precomputed.doubles.points.slice(1),\n    },\n    naf: this.precomputed.naf && {\n      wnd: this.precomputed.naf.wnd,\n      points: this.precomputed.naf.points.slice(1),\n    },\n  } ];\n};\n\nPoint.fromJSON = function fromJSON(curve, obj, red) {\n  if (typeof obj === 'string')\n    obj = JSON.parse(obj);\n  var res = curve.point(obj[0], obj[1], red);\n  if (!obj[2])\n    return res;\n\n  function obj2point(obj) {\n    return curve.point(obj[0], obj[1], red);\n  }\n\n  var pre = obj[2];\n  res.precomputed = {\n    beta: null,\n    doubles: pre.doubles && {\n      step: pre.doubles.step,\n      points: [ res ].concat(pre.doubles.points.map(obj2point)),\n    },\n    naf: pre.naf && {\n      wnd: pre.naf.wnd,\n      points: [ res ].concat(pre.naf.points.map(obj2point)),\n    },\n  };\n  return res;\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n      ' y: ' + this.y.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  return this.inf;\n};\n\nPoint.prototype.add = function add(p) {\n  // O + P = P\n  if (this.inf)\n    return p;\n\n  // P + O = P\n  if (p.inf)\n    return this;\n\n  // P + P = 2P\n  if (this.eq(p))\n    return this.dbl();\n\n  // P + (-P) = O\n  if (this.neg().eq(p))\n    return this.curve.point(null, null);\n\n  // P + Q = O\n  if (this.x.cmp(p.x) === 0)\n    return this.curve.point(null, null);\n\n  var c = this.y.redSub(p.y);\n  if (c.cmpn(0) !== 0)\n    c = c.redMul(this.x.redSub(p.x).redInvm());\n  var nx = c.redSqr().redISub(this.x).redISub(p.x);\n  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n  return this.curve.point(nx, ny);\n};\n\nPoint.prototype.dbl = function dbl() {\n  if (this.inf)\n    return this;\n\n  // 2P = O\n  var ys1 = this.y.redAdd(this.y);\n  if (ys1.cmpn(0) === 0)\n    return this.curve.point(null, null);\n\n  var a = this.curve.a;\n\n  var x2 = this.x.redSqr();\n  var dyinv = ys1.redInvm();\n  var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);\n\n  var nx = c.redSqr().redISub(this.x.redAdd(this.x));\n  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n  return this.curve.point(nx, ny);\n};\n\nPoint.prototype.getX = function getX() {\n  return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n  return this.y.fromRed();\n};\n\nPoint.prototype.mul = function mul(k) {\n  k = new BN(k, 16);\n  if (this.isInfinity())\n    return this;\n  else if (this._hasDoubles(k))\n    return this.curve._fixedNafMul(this, k);\n  else if (this.curve.endo)\n    return this.curve._endoWnafMulAdd([ this ], [ k ]);\n  else\n    return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p2, k2) {\n  var points = [ this, p2 ];\n  var coeffs = [ k1, k2 ];\n  if (this.curve.endo)\n    return this.curve._endoWnafMulAdd(points, coeffs);\n  else\n    return this.curve._wnafMulAdd(1, points, coeffs, 2);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {\n  var points = [ this, p2 ];\n  var coeffs = [ k1, k2 ];\n  if (this.curve.endo)\n    return this.curve._endoWnafMulAdd(points, coeffs, true);\n  else\n    return this.curve._wnafMulAdd(1, points, coeffs, 2, true);\n};\n\nPoint.prototype.eq = function eq(p) {\n  return this === p ||\n         this.inf === p.inf &&\n             (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);\n};\n\nPoint.prototype.neg = function neg(_precompute) {\n  if (this.inf)\n    return this;\n\n  var res = this.curve.point(this.x, this.y.redNeg());\n  if (_precompute && this.precomputed) {\n    var pre = this.precomputed;\n    var negate = function(p) {\n      return p.neg();\n    };\n    res.precomputed = {\n      naf: pre.naf && {\n        wnd: pre.naf.wnd,\n        points: pre.naf.points.map(negate),\n      },\n      doubles: pre.doubles && {\n        step: pre.doubles.step,\n        points: pre.doubles.points.map(negate),\n      },\n    };\n  }\n  return res;\n};\n\nPoint.prototype.toJ = function toJ() {\n  if (this.inf)\n    return this.curve.jpoint(null, null, null);\n\n  var res = this.curve.jpoint(this.x, this.y, this.curve.one);\n  return res;\n};\n\nfunction JPoint(curve, x, y, z) {\n  base.BasePoint.call(this, curve, 'jacobian');\n  if (x === null && y === null && z === null) {\n    this.x = this.curve.one;\n    this.y = this.curve.one;\n    this.z = new BN(0);\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    this.z = new BN(z, 16);\n  }\n  if (!this.x.red)\n    this.x = this.x.toRed(this.curve.red);\n  if (!this.y.red)\n    this.y = this.y.toRed(this.curve.red);\n  if (!this.z.red)\n    this.z = this.z.toRed(this.curve.red);\n\n  this.zOne = this.z === this.curve.one;\n}\ninherits_browser(JPoint, base.BasePoint);\n\nShortCurve.prototype.jpoint = function jpoint(x, y, z) {\n  return new JPoint(this, x, y, z);\n};\n\nJPoint.prototype.toP = function toP() {\n  if (this.isInfinity())\n    return this.curve.point(null, null);\n\n  var zinv = this.z.redInvm();\n  var zinv2 = zinv.redSqr();\n  var ax = this.x.redMul(zinv2);\n  var ay = this.y.redMul(zinv2).redMul(zinv);\n\n  return this.curve.point(ax, ay);\n};\n\nJPoint.prototype.neg = function neg() {\n  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);\n};\n\nJPoint.prototype.add = function add(p) {\n  // O + P = P\n  if (this.isInfinity())\n    return p;\n\n  // P + O = P\n  if (p.isInfinity())\n    return this;\n\n  // 12M + 4S + 7A\n  var pz2 = p.z.redSqr();\n  var z2 = this.z.redSqr();\n  var u1 = this.x.redMul(pz2);\n  var u2 = p.x.redMul(z2);\n  var s1 = this.y.redMul(pz2.redMul(p.z));\n  var s2 = p.y.redMul(z2.redMul(this.z));\n\n  var h = u1.redSub(u2);\n  var r = s1.redSub(s2);\n  if (h.cmpn(0) === 0) {\n    if (r.cmpn(0) !== 0)\n      return this.curve.jpoint(null, null, null);\n    else\n      return this.dbl();\n  }\n\n  var h2 = h.redSqr();\n  var h3 = h2.redMul(h);\n  var v = u1.redMul(h2);\n\n  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n  var nz = this.z.redMul(p.z).redMul(h);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mixedAdd = function mixedAdd(p) {\n  // O + P = P\n  if (this.isInfinity())\n    return p.toJ();\n\n  // P + O = P\n  if (p.isInfinity())\n    return this;\n\n  // 8M + 3S + 7A\n  var z2 = this.z.redSqr();\n  var u1 = this.x;\n  var u2 = p.x.redMul(z2);\n  var s1 = this.y;\n  var s2 = p.y.redMul(z2).redMul(this.z);\n\n  var h = u1.redSub(u2);\n  var r = s1.redSub(s2);\n  if (h.cmpn(0) === 0) {\n    if (r.cmpn(0) !== 0)\n      return this.curve.jpoint(null, null, null);\n    else\n      return this.dbl();\n  }\n\n  var h2 = h.redSqr();\n  var h3 = h2.redMul(h);\n  var v = u1.redMul(h2);\n\n  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n  var nz = this.z.redMul(h);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.dblp = function dblp(pow) {\n  if (pow === 0)\n    return this;\n  if (this.isInfinity())\n    return this;\n  if (!pow)\n    return this.dbl();\n\n  var i;\n  if (this.curve.zeroA || this.curve.threeA) {\n    var r = this;\n    for (i = 0; i < pow; i++)\n      r = r.dbl();\n    return r;\n  }\n\n  // 1M + 2S + 1A + N * (4S + 5M + 8A)\n  // N = 1 => 6M + 6S + 9A\n  var a = this.curve.a;\n  var tinv = this.curve.tinv;\n\n  var jx = this.x;\n  var jy = this.y;\n  var jz = this.z;\n  var jz4 = jz.redSqr().redSqr();\n\n  // Reuse results\n  var jyd = jy.redAdd(jy);\n  for (i = 0; i < pow; i++) {\n    var jx2 = jx.redSqr();\n    var jyd2 = jyd.redSqr();\n    var jyd4 = jyd2.redSqr();\n    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n    var t1 = jx.redMul(jyd2);\n    var nx = c.redSqr().redISub(t1.redAdd(t1));\n    var t2 = t1.redISub(nx);\n    var dny = c.redMul(t2);\n    dny = dny.redIAdd(dny).redISub(jyd4);\n    var nz = jyd.redMul(jz);\n    if (i + 1 < pow)\n      jz4 = jz4.redMul(jyd4);\n\n    jx = nx;\n    jz = nz;\n    jyd = dny;\n  }\n\n  return this.curve.jpoint(jx, jyd.redMul(tinv), jz);\n};\n\nJPoint.prototype.dbl = function dbl() {\n  if (this.isInfinity())\n    return this;\n\n  if (this.curve.zeroA)\n    return this._zeroDbl();\n  else if (this.curve.threeA)\n    return this._threeDbl();\n  else\n    return this._dbl();\n};\n\nJPoint.prototype._zeroDbl = function _zeroDbl() {\n  var nx;\n  var ny;\n  var nz;\n  // Z = 1\n  if (this.zOne) {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n    //     #doubling-mdbl-2007-bl\n    // 1M + 5S + 14A\n\n    // XX = X1^2\n    var xx = this.x.redSqr();\n    // YY = Y1^2\n    var yy = this.y.redSqr();\n    // YYYY = YY^2\n    var yyyy = yy.redSqr();\n    // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n    s = s.redIAdd(s);\n    // M = 3 * XX + a; a = 0\n    var m = xx.redAdd(xx).redIAdd(xx);\n    // T = M ^ 2 - 2*S\n    var t = m.redSqr().redISub(s).redISub(s);\n\n    // 8 * YYYY\n    var yyyy8 = yyyy.redIAdd(yyyy);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n\n    // X3 = T\n    nx = t;\n    // Y3 = M * (S - T) - 8 * YYYY\n    ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n    // Z3 = 2*Y1\n    nz = this.y.redAdd(this.y);\n  } else {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n    //     #doubling-dbl-2009-l\n    // 2M + 5S + 13A\n\n    // A = X1^2\n    var a = this.x.redSqr();\n    // B = Y1^2\n    var b = this.y.redSqr();\n    // C = B^2\n    var c = b.redSqr();\n    // D = 2 * ((X1 + B)^2 - A - C)\n    var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);\n    d = d.redIAdd(d);\n    // E = 3 * A\n    var e = a.redAdd(a).redIAdd(a);\n    // F = E^2\n    var f = e.redSqr();\n\n    // 8 * C\n    var c8 = c.redIAdd(c);\n    c8 = c8.redIAdd(c8);\n    c8 = c8.redIAdd(c8);\n\n    // X3 = F - 2 * D\n    nx = f.redISub(d).redISub(d);\n    // Y3 = E * (D - X3) - 8 * C\n    ny = e.redMul(d.redISub(nx)).redISub(c8);\n    // Z3 = 2 * Y1 * Z1\n    nz = this.y.redMul(this.z);\n    nz = nz.redIAdd(nz);\n  }\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._threeDbl = function _threeDbl() {\n  var nx;\n  var ny;\n  var nz;\n  // Z = 1\n  if (this.zOne) {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html\n    //     #doubling-mdbl-2007-bl\n    // 1M + 5S + 15A\n\n    // XX = X1^2\n    var xx = this.x.redSqr();\n    // YY = Y1^2\n    var yy = this.y.redSqr();\n    // YYYY = YY^2\n    var yyyy = yy.redSqr();\n    // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n    s = s.redIAdd(s);\n    // M = 3 * XX + a\n    var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);\n    // T = M^2 - 2 * S\n    var t = m.redSqr().redISub(s).redISub(s);\n    // X3 = T\n    nx = t;\n    // Y3 = M * (S - T) - 8 * YYYY\n    var yyyy8 = yyyy.redIAdd(yyyy);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n    // Z3 = 2 * Y1\n    nz = this.y.redAdd(this.y);\n  } else {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b\n    // 3M + 5S\n\n    // delta = Z1^2\n    var delta = this.z.redSqr();\n    // gamma = Y1^2\n    var gamma = this.y.redSqr();\n    // beta = X1 * gamma\n    var beta = this.x.redMul(gamma);\n    // alpha = 3 * (X1 - delta) * (X1 + delta)\n    var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));\n    alpha = alpha.redAdd(alpha).redIAdd(alpha);\n    // X3 = alpha^2 - 8 * beta\n    var beta4 = beta.redIAdd(beta);\n    beta4 = beta4.redIAdd(beta4);\n    var beta8 = beta4.redAdd(beta4);\n    nx = alpha.redSqr().redISub(beta8);\n    // Z3 = (Y1 + Z1)^2 - gamma - delta\n    nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);\n    // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2\n    var ggamma8 = gamma.redSqr();\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);\n  }\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._dbl = function _dbl() {\n  var a = this.curve.a;\n\n  // 4M + 6S + 10A\n  var jx = this.x;\n  var jy = this.y;\n  var jz = this.z;\n  var jz4 = jz.redSqr().redSqr();\n\n  var jx2 = jx.redSqr();\n  var jy2 = jy.redSqr();\n\n  var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n  var jxd4 = jx.redAdd(jx);\n  jxd4 = jxd4.redIAdd(jxd4);\n  var t1 = jxd4.redMul(jy2);\n  var nx = c.redSqr().redISub(t1.redAdd(t1));\n  var t2 = t1.redISub(nx);\n\n  var jyd8 = jy2.redSqr();\n  jyd8 = jyd8.redIAdd(jyd8);\n  jyd8 = jyd8.redIAdd(jyd8);\n  jyd8 = jyd8.redIAdd(jyd8);\n  var ny = c.redMul(t2).redISub(jyd8);\n  var nz = jy.redAdd(jy).redMul(jz);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.trpl = function trpl() {\n  if (!this.curve.zeroA)\n    return this.dbl().add(this);\n\n  // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl\n  // 5M + 10S + ...\n\n  // XX = X1^2\n  var xx = this.x.redSqr();\n  // YY = Y1^2\n  var yy = this.y.redSqr();\n  // ZZ = Z1^2\n  var zz = this.z.redSqr();\n  // YYYY = YY^2\n  var yyyy = yy.redSqr();\n  // M = 3 * XX + a * ZZ2; a = 0\n  var m = xx.redAdd(xx).redIAdd(xx);\n  // MM = M^2\n  var mm = m.redSqr();\n  // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM\n  var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n  e = e.redIAdd(e);\n  e = e.redAdd(e).redIAdd(e);\n  e = e.redISub(mm);\n  // EE = E^2\n  var ee = e.redSqr();\n  // T = 16*YYYY\n  var t = yyyy.redIAdd(yyyy);\n  t = t.redIAdd(t);\n  t = t.redIAdd(t);\n  t = t.redIAdd(t);\n  // U = (M + E)^2 - MM - EE - T\n  var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);\n  // X3 = 4 * (X1 * EE - 4 * YY * U)\n  var yyu4 = yy.redMul(u);\n  yyu4 = yyu4.redIAdd(yyu4);\n  yyu4 = yyu4.redIAdd(yyu4);\n  var nx = this.x.redMul(ee).redISub(yyu4);\n  nx = nx.redIAdd(nx);\n  nx = nx.redIAdd(nx);\n  // Y3 = 8 * Y1 * (U * (T - U) - E * EE)\n  var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));\n  ny = ny.redIAdd(ny);\n  ny = ny.redIAdd(ny);\n  ny = ny.redIAdd(ny);\n  // Z3 = (Z1 + E)^2 - ZZ - EE\n  var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mul = function mul(k, kbase) {\n  k = new BN(k, kbase);\n\n  return this.curve._wnafMul(this, k);\n};\n\nJPoint.prototype.eq = function eq(p) {\n  if (p.type === 'affine')\n    return this.eq(p.toJ());\n\n  if (this === p)\n    return true;\n\n  // x1 * z2^2 == x2 * z1^2\n  var z2 = this.z.redSqr();\n  var pz2 = p.z.redSqr();\n  if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)\n    return false;\n\n  // y1 * z2^3 == y2 * z1^3\n  var z3 = z2.redMul(this.z);\n  var pz3 = pz2.redMul(p.z);\n  return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;\n};\n\nJPoint.prototype.eqXToP = function eqXToP(x) {\n  var zs = this.z.redSqr();\n  var rx = x.toRed(this.curve.red).redMul(zs);\n  if (this.x.cmp(rx) === 0)\n    return true;\n\n  var xc = x.clone();\n  var t = this.curve.redN.redMul(zs);\n  for (;;) {\n    xc.iadd(this.curve.n);\n    if (xc.cmp(this.curve.p) >= 0)\n      return false;\n\n    rx.redIAdd(t);\n    if (this.x.cmp(rx) === 0)\n      return true;\n  }\n};\n\nJPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC JPoint Infinity>';\n  return '<EC JPoint x: ' + this.x.toString(16, 2) +\n      ' y: ' + this.y.toString(16, 2) +\n      ' z: ' + this.z.toString(16, 2) + '>';\n};\n\nJPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.z.cmpn(0) === 0;\n};\n\nvar curve_1 = createCommonjsModule(function (module, exports) {\n'use strict';\n\nvar curve = exports;\n\ncurve.base = base;\ncurve.short = short_1;\ncurve.mont = /*RicMoo:ethers:require(./mont)*/(null);\ncurve.edwards = /*RicMoo:ethers:require(./edwards)*/(null);\n});\n\nvar curves_1 = createCommonjsModule(function (module, exports) {\n'use strict';\n\nvar curves = exports;\n\n\n\n\n\nvar assert = utils_1$1.assert;\n\nfunction PresetCurve(options) {\n  if (options.type === 'short')\n    this.curve = new curve_1.short(options);\n  else if (options.type === 'edwards')\n    this.curve = new curve_1.edwards(options);\n  else\n    this.curve = new curve_1.mont(options);\n  this.g = this.curve.g;\n  this.n = this.curve.n;\n  this.hash = options.hash;\n\n  assert(this.g.validate(), 'Invalid curve');\n  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');\n}\ncurves.PresetCurve = PresetCurve;\n\nfunction defineCurve(name, options) {\n  Object.defineProperty(curves, name, {\n    configurable: true,\n    enumerable: true,\n    get: function() {\n      var curve = new PresetCurve(options);\n      Object.defineProperty(curves, name, {\n        configurable: true,\n        enumerable: true,\n        value: curve,\n      });\n      return curve;\n    },\n  });\n}\n\ndefineCurve('p192', {\n  type: 'short',\n  prime: 'p192',\n  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',\n  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',\n  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',\n    '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811',\n  ],\n});\n\ndefineCurve('p224', {\n  type: 'short',\n  prime: 'p224',\n  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',\n  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',\n  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',\n    'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34',\n  ],\n});\n\ndefineCurve('p256', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',\n  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',\n  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',\n  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',\n    '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5',\n  ],\n});\n\ndefineCurve('p384', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'fffffffe ffffffff 00000000 00000000 ffffffff',\n  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'fffffffe ffffffff 00000000 00000000 fffffffc',\n  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +\n     '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',\n  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +\n     'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',\n  hash: hash.sha384,\n  gRed: false,\n  g: [\n    'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +\n    '5502f25d bf55296c 3a545e38 72760ab7',\n    '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +\n    '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f',\n  ],\n});\n\ndefineCurve('p521', {\n  type: 'short',\n  prime: null,\n  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff',\n  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff fffffffc',\n  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +\n     '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +\n     '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',\n  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +\n     'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',\n  hash: hash.sha512,\n  gRed: false,\n  g: [\n    '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +\n    '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +\n    'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',\n    '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +\n    '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +\n    '3fad0761 353c7086 a272c240 88be9476 9fd16650',\n  ],\n});\n\ndefineCurve('curve25519', {\n  type: 'mont',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '76d06',\n  b: '1',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '9',\n  ],\n});\n\ndefineCurve('ed25519', {\n  type: 'edwards',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '-1',\n  c: '1',\n  // -121665 * (121666^(-1)) (mod P)\n  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',\n\n    // 4/5\n    '6666666666666666666666666666666666666666666666666666666666666658',\n  ],\n});\n\nvar pre;\ntry {\n  pre = /*RicMoo:ethers:require(./precomputed/secp256k1)*/(null).crash();\n} catch (e) {\n  pre = undefined;\n}\n\ndefineCurve('secp256k1', {\n  type: 'short',\n  prime: 'k256',\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',\n  a: '0',\n  b: '7',\n  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',\n  h: '1',\n  hash: hash.sha256,\n\n  // Precomputed endomorphism\n  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',\n  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',\n  basis: [\n    {\n      a: '3086d221a7d46bcde86c90e49284eb15',\n      b: '-e4437ed6010e88286f547fa90abfe4c3',\n    },\n    {\n      a: '114ca50f7a8e2f3f657c1108d9d44cfd8',\n      b: '3086d221a7d46bcde86c90e49284eb15',\n    },\n  ],\n\n  gRed: false,\n  g: [\n    '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',\n    '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',\n    pre,\n  ],\n});\n});\n\n'use strict';\n\n\n\n\n\nfunction HmacDRBG(options) {\n  if (!(this instanceof HmacDRBG))\n    return new HmacDRBG(options);\n  this.hash = options.hash;\n  this.predResist = !!options.predResist;\n\n  this.outLen = this.hash.outSize;\n  this.minEntropy = options.minEntropy || this.hash.hmacStrength;\n\n  this._reseed = null;\n  this.reseedInterval = null;\n  this.K = null;\n  this.V = null;\n\n  var entropy = utils_1.toArray(options.entropy, options.entropyEnc || 'hex');\n  var nonce = utils_1.toArray(options.nonce, options.nonceEnc || 'hex');\n  var pers = utils_1.toArray(options.pers, options.persEnc || 'hex');\n  minimalisticAssert(entropy.length >= (this.minEntropy / 8),\n         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n  this._init(entropy, nonce, pers);\n}\nvar hmacDrbg = HmacDRBG;\n\nHmacDRBG.prototype._init = function init(entropy, nonce, pers) {\n  var seed = entropy.concat(nonce).concat(pers);\n\n  this.K = new Array(this.outLen / 8);\n  this.V = new Array(this.outLen / 8);\n  for (var i = 0; i < this.V.length; i++) {\n    this.K[i] = 0x00;\n    this.V[i] = 0x01;\n  }\n\n  this._update(seed);\n  this._reseed = 1;\n  this.reseedInterval = 0x1000000000000;  // 2^48\n};\n\nHmacDRBG.prototype._hmac = function hmac() {\n  return new hash.hmac(this.hash, this.K);\n};\n\nHmacDRBG.prototype._update = function update(seed) {\n  var kmac = this._hmac()\n                 .update(this.V)\n                 .update([ 0x00 ]);\n  if (seed)\n    kmac = kmac.update(seed);\n  this.K = kmac.digest();\n  this.V = this._hmac().update(this.V).digest();\n  if (!seed)\n    return;\n\n  this.K = this._hmac()\n               .update(this.V)\n               .update([ 0x01 ])\n               .update(seed)\n               .digest();\n  this.V = this._hmac().update(this.V).digest();\n};\n\nHmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {\n  // Optional entropy enc\n  if (typeof entropyEnc !== 'string') {\n    addEnc = add;\n    add = entropyEnc;\n    entropyEnc = null;\n  }\n\n  entropy = utils_1.toArray(entropy, entropyEnc);\n  add = utils_1.toArray(add, addEnc);\n\n  minimalisticAssert(entropy.length >= (this.minEntropy / 8),\n         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n\n  this._update(entropy.concat(add || []));\n  this._reseed = 1;\n};\n\nHmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {\n  if (this._reseed > this.reseedInterval)\n    throw new Error('Reseed is required');\n\n  // Optional encoding\n  if (typeof enc !== 'string') {\n    addEnc = add;\n    add = enc;\n    enc = null;\n  }\n\n  // Optional additional data\n  if (add) {\n    add = utils_1.toArray(add, addEnc || 'hex');\n    this._update(add);\n  }\n\n  var temp = [];\n  while (temp.length < len) {\n    this.V = this._hmac().update(this.V).digest();\n    temp = temp.concat(this.V);\n  }\n\n  var res = temp.slice(0, len);\n  this._update(add);\n  this._reseed++;\n  return utils_1.encode(res, enc);\n};\n\n'use strict';\n\n\n\nvar assert$3 = utils_1$1.assert;\n\nfunction KeyPair(ec, options) {\n  this.ec = ec;\n  this.priv = null;\n  this.pub = null;\n\n  // KeyPair(ec, { priv: ..., pub: ... })\n  if (options.priv)\n    this._importPrivate(options.priv, options.privEnc);\n  if (options.pub)\n    this._importPublic(options.pub, options.pubEnc);\n}\nvar key = KeyPair;\n\nKeyPair.fromPublic = function fromPublic(ec, pub, enc) {\n  if (pub instanceof KeyPair)\n    return pub;\n\n  return new KeyPair(ec, {\n    pub: pub,\n    pubEnc: enc,\n  });\n};\n\nKeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {\n  if (priv instanceof KeyPair)\n    return priv;\n\n  return new KeyPair(ec, {\n    priv: priv,\n    privEnc: enc,\n  });\n};\n\nKeyPair.prototype.validate = function validate() {\n  var pub = this.getPublic();\n\n  if (pub.isInfinity())\n    return { result: false, reason: 'Invalid public key' };\n  if (!pub.validate())\n    return { result: false, reason: 'Public key is not a point' };\n  if (!pub.mul(this.ec.curve.n).isInfinity())\n    return { result: false, reason: 'Public key * N != O' };\n\n  return { result: true, reason: null };\n};\n\nKeyPair.prototype.getPublic = function getPublic(compact, enc) {\n  // compact is optional argument\n  if (typeof compact === 'string') {\n    enc = compact;\n    compact = null;\n  }\n\n  if (!this.pub)\n    this.pub = this.ec.g.mul(this.priv);\n\n  if (!enc)\n    return this.pub;\n\n  return this.pub.encode(enc, compact);\n};\n\nKeyPair.prototype.getPrivate = function getPrivate(enc) {\n  if (enc === 'hex')\n    return this.priv.toString(16, 2);\n  else\n    return this.priv;\n};\n\nKeyPair.prototype._importPrivate = function _importPrivate(key, enc) {\n  this.priv = new BN(key, enc || 16);\n\n  // Ensure that the priv won't be bigger than n, otherwise we may fail\n  // in fixed multiplication method\n  this.priv = this.priv.umod(this.ec.curve.n);\n};\n\nKeyPair.prototype._importPublic = function _importPublic(key, enc) {\n  if (key.x || key.y) {\n    // Montgomery points only have an `x` coordinate.\n    // Weierstrass/Edwards points on the other hand have both `x` and\n    // `y` coordinates.\n    if (this.ec.curve.type === 'mont') {\n      assert$3(key.x, 'Need x coordinate');\n    } else if (this.ec.curve.type === 'short' ||\n               this.ec.curve.type === 'edwards') {\n      assert$3(key.x && key.y, 'Need both x and y coordinate');\n    }\n    this.pub = this.ec.curve.point(key.x, key.y);\n    return;\n  }\n  this.pub = this.ec.curve.decodePoint(key, enc);\n};\n\n// ECDH\nKeyPair.prototype.derive = function derive(pub) {\n  if(!pub.validate()) {\n    assert$3(pub.validate(), 'public point not validated');\n  }\n  return pub.mul(this.priv).getX();\n};\n\n// ECDSA\nKeyPair.prototype.sign = function sign(msg, enc, options) {\n  return this.ec.sign(msg, this, enc, options);\n};\n\nKeyPair.prototype.verify = function verify(msg, signature) {\n  return this.ec.verify(msg, signature, this);\n};\n\nKeyPair.prototype.inspect = function inspect() {\n  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +\n         ' pub: ' + (this.pub && this.pub.inspect()) + ' >';\n};\n\n'use strict';\n\n\n\n\nvar assert$4 = utils_1$1.assert;\n\nfunction Signature(options, enc) {\n  if (options instanceof Signature)\n    return options;\n\n  if (this._importDER(options, enc))\n    return;\n\n  assert$4(options.r && options.s, 'Signature without r or s');\n  this.r = new BN(options.r, 16);\n  this.s = new BN(options.s, 16);\n  if (options.recoveryParam === undefined)\n    this.recoveryParam = null;\n  else\n    this.recoveryParam = options.recoveryParam;\n}\nvar signature = Signature;\n\nfunction Position() {\n  this.place = 0;\n}\n\nfunction getLength(buf, p) {\n  var initial = buf[p.place++];\n  if (!(initial & 0x80)) {\n    return initial;\n  }\n  var octetLen = initial & 0xf;\n\n  // Indefinite length or overflow\n  if (octetLen === 0 || octetLen > 4) {\n    return false;\n  }\n\n  var val = 0;\n  for (var i = 0, off = p.place; i < octetLen; i++, off++) {\n    val <<= 8;\n    val |= buf[off];\n    val >>>= 0;\n  }\n\n  // Leading zeroes\n  if (val <= 0x7f) {\n    return false;\n  }\n\n  p.place = off;\n  return val;\n}\n\nfunction rmPadding(buf) {\n  var i = 0;\n  var len = buf.length - 1;\n  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {\n    i++;\n  }\n  if (i === 0) {\n    return buf;\n  }\n  return buf.slice(i);\n}\n\nSignature.prototype._importDER = function _importDER(data, enc) {\n  data = utils_1$1.toArray(data, enc);\n  var p = new Position();\n  if (data[p.place++] !== 0x30) {\n    return false;\n  }\n  var len = getLength(data, p);\n  if (len === false) {\n    return false;\n  }\n  if ((len + p.place) !== data.length) {\n    return false;\n  }\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var rlen = getLength(data, p);\n  if (rlen === false) {\n    return false;\n  }\n  var r = data.slice(p.place, rlen + p.place);\n  p.place += rlen;\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var slen = getLength(data, p);\n  if (slen === false) {\n    return false;\n  }\n  if (data.length !== slen + p.place) {\n    return false;\n  }\n  var s = data.slice(p.place, slen + p.place);\n  if (r[0] === 0) {\n    if (r[1] & 0x80) {\n      r = r.slice(1);\n    } else {\n      // Leading zeroes\n      return false;\n    }\n  }\n  if (s[0] === 0) {\n    if (s[1] & 0x80) {\n      s = s.slice(1);\n    } else {\n      // Leading zeroes\n      return false;\n    }\n  }\n\n  this.r = new BN(r);\n  this.s = new BN(s);\n  this.recoveryParam = null;\n\n  return true;\n};\n\nfunction constructLength(arr, len) {\n  if (len < 0x80) {\n    arr.push(len);\n    return;\n  }\n  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);\n  arr.push(octets | 0x80);\n  while (--octets) {\n    arr.push((len >>> (octets << 3)) & 0xff);\n  }\n  arr.push(len);\n}\n\nSignature.prototype.toDER = function toDER(enc) {\n  var r = this.r.toArray();\n  var s = this.s.toArray();\n\n  // Pad values\n  if (r[0] & 0x80)\n    r = [ 0 ].concat(r);\n  // Pad values\n  if (s[0] & 0x80)\n    s = [ 0 ].concat(s);\n\n  r = rmPadding(r);\n  s = rmPadding(s);\n\n  while (!s[0] && !(s[1] & 0x80)) {\n    s = s.slice(1);\n  }\n  var arr = [ 0x02 ];\n  constructLength(arr, r.length);\n  arr = arr.concat(r);\n  arr.push(0x02);\n  constructLength(arr, s.length);\n  var backHalf = arr.concat(s);\n  var res = [ 0x30 ];\n  constructLength(res, backHalf.length);\n  res = res.concat(backHalf);\n  return utils_1$1.encode(res, enc);\n};\n\n'use strict';\n\n\n\n\n\nvar rand = /*RicMoo:ethers:require(brorand)*/(function() { throw new Error('unsupported'); });\nvar assert$5 = utils_1$1.assert;\n\n\n\n\nfunction EC(options) {\n  if (!(this instanceof EC))\n    return new EC(options);\n\n  // Shortcut `elliptic.ec(curve-name)`\n  if (typeof options === 'string') {\n    assert$5(Object.prototype.hasOwnProperty.call(curves_1, options),\n      'Unknown curve ' + options);\n\n    options = curves_1[options];\n  }\n\n  // Shortcut for `elliptic.ec(elliptic.curves.curveName)`\n  if (options instanceof curves_1.PresetCurve)\n    options = { curve: options };\n\n  this.curve = options.curve.curve;\n  this.n = this.curve.n;\n  this.nh = this.n.ushrn(1);\n  this.g = this.curve.g;\n\n  // Point on curve\n  this.g = options.curve.g;\n  this.g.precompute(options.curve.n.bitLength() + 1);\n\n  // Hash for function for DRBG\n  this.hash = options.hash || options.curve.hash;\n}\nvar ec = EC;\n\nEC.prototype.keyPair = function keyPair(options) {\n  return new key(this, options);\n};\n\nEC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {\n  return key.fromPrivate(this, priv, enc);\n};\n\nEC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {\n  return key.fromPublic(this, pub, enc);\n};\n\nEC.prototype.genKeyPair = function genKeyPair(options) {\n  if (!options)\n    options = {};\n\n  // Instantiate Hmac_DRBG\n  var drbg = new hmacDrbg({\n    hash: this.hash,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8',\n    entropy: options.entropy || rand(this.hash.hmacStrength),\n    entropyEnc: options.entropy && options.entropyEnc || 'utf8',\n    nonce: this.n.toArray(),\n  });\n\n  var bytes = this.n.byteLength();\n  var ns2 = this.n.sub(new BN(2));\n  for (;;) {\n    var priv = new BN(drbg.generate(bytes));\n    if (priv.cmp(ns2) > 0)\n      continue;\n\n    priv.iaddn(1);\n    return this.keyFromPrivate(priv);\n  }\n};\n\nEC.prototype._truncateToN = function _truncateToN(msg, truncOnly) {\n  var delta = msg.byteLength() * 8 - this.n.bitLength();\n  if (delta > 0)\n    msg = msg.ushrn(delta);\n  if (!truncOnly && msg.cmp(this.n) >= 0)\n    return msg.sub(this.n);\n  else\n    return msg;\n};\n\nEC.prototype.sign = function sign(msg, key, enc, options) {\n  if (typeof enc === 'object') {\n    options = enc;\n    enc = null;\n  }\n  if (!options)\n    options = {};\n\n  key = this.keyFromPrivate(key, enc);\n  msg = this._truncateToN(new BN(msg, 16));\n\n  // Zero-extend key to provide enough entropy\n  var bytes = this.n.byteLength();\n  var bkey = key.getPrivate().toArray('be', bytes);\n\n  // Zero-extend nonce to have the same byte size as N\n  var nonce = msg.toArray('be', bytes);\n\n  // Instantiate Hmac_DRBG\n  var drbg = new hmacDrbg({\n    hash: this.hash,\n    entropy: bkey,\n    nonce: nonce,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8',\n  });\n\n  // Number of bytes to generate\n  var ns1 = this.n.sub(new BN(1));\n\n  for (var iter = 0; ; iter++) {\n    var k = options.k ?\n      options.k(iter) :\n      new BN(drbg.generate(this.n.byteLength()));\n    k = this._truncateToN(k, true);\n    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)\n      continue;\n\n    var kp = this.g.mul(k);\n    if (kp.isInfinity())\n      continue;\n\n    var kpX = kp.getX();\n    var r = kpX.umod(this.n);\n    if (r.cmpn(0) === 0)\n      continue;\n\n    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));\n    s = s.umod(this.n);\n    if (s.cmpn(0) === 0)\n      continue;\n\n    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |\n                        (kpX.cmp(r) !== 0 ? 2 : 0);\n\n    // Use complement of `s`, if it is > `n / 2`\n    if (options.canonical && s.cmp(this.nh) > 0) {\n      s = this.n.sub(s);\n      recoveryParam ^= 1;\n    }\n\n    return new signature({ r: r, s: s, recoveryParam: recoveryParam });\n  }\n};\n\nEC.prototype.verify = function verify(msg, signature$1, key, enc) {\n  msg = this._truncateToN(new BN(msg, 16));\n  key = this.keyFromPublic(key, enc);\n  signature$1 = new signature(signature$1, 'hex');\n\n  // Perform primitive values validation\n  var r = signature$1.r;\n  var s = signature$1.s;\n  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)\n    return false;\n  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)\n    return false;\n\n  // Validate signature\n  var sinv = s.invm(this.n);\n  var u1 = sinv.mul(msg).umod(this.n);\n  var u2 = sinv.mul(r).umod(this.n);\n  var p;\n\n  if (!this.curve._maxwellTrick) {\n    p = this.g.mulAdd(u1, key.getPublic(), u2);\n    if (p.isInfinity())\n      return false;\n\n    return p.getX().umod(this.n).cmp(r) === 0;\n  }\n\n  // NOTE: Greg Maxwell's trick, inspired by:\n  // https://git.io/vad3K\n\n  p = this.g.jmulAdd(u1, key.getPublic(), u2);\n  if (p.isInfinity())\n    return false;\n\n  // Compare `p.x` of Jacobian point with `r`,\n  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the\n  // inverse of `p.z^2`\n  return p.eqXToP(r);\n};\n\nEC.prototype.recoverPubKey = function(msg, signature$1, j, enc) {\n  assert$5((3 & j) === j, 'The recovery param is more than two bits');\n  signature$1 = new signature(signature$1, enc);\n\n  var n = this.n;\n  var e = new BN(msg);\n  var r = signature$1.r;\n  var s = signature$1.s;\n\n  // A set LSB signifies that the y-coordinate is odd\n  var isYOdd = j & 1;\n  var isSecondKey = j >> 1;\n  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)\n    throw new Error('Unable to find sencond key candinate');\n\n  // 1.1. Let x = r + jn.\n  if (isSecondKey)\n    r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);\n  else\n    r = this.curve.pointFromX(r, isYOdd);\n\n  var rInv = signature$1.r.invm(n);\n  var s1 = n.sub(e).mul(rInv).umod(n);\n  var s2 = s.mul(rInv).umod(n);\n\n  // 1.6.1 Compute Q = r^-1 (sR -  eG)\n  //               Q = r^-1 (sR + -eG)\n  return this.g.mulAdd(s1, r, s2);\n};\n\nEC.prototype.getKeyRecoveryParam = function(e, signature$1, Q, enc) {\n  signature$1 = new signature(signature$1, enc);\n  if (signature$1.recoveryParam !== null)\n    return signature$1.recoveryParam;\n\n  for (var i = 0; i < 4; i++) {\n    var Qprime;\n    try {\n      Qprime = this.recoverPubKey(e, signature$1, i);\n    } catch (e) {\n      continue;\n    }\n\n    if (Qprime.eq(Q))\n      return i;\n  }\n  throw new Error('Unable to find valid recovery factor');\n};\n\nvar elliptic_1 = createCommonjsModule(function (module, exports) {\n'use strict';\n\nvar elliptic = exports;\n\nelliptic.version = /*RicMoo:ethers*/{ version: \"6.5.4\" }.version;\nelliptic.utils = utils_1$1;\nelliptic.rand = /*RicMoo:ethers:require(brorand)*/(function() { throw new Error('unsupported'); });\nelliptic.curve = curve_1;\nelliptic.curves = curves_1;\n\n// Protocols\nelliptic.ec = ec;\nelliptic.eddsa = /*RicMoo:ethers:require(./elliptic/eddsa)*/(null);\n});\n\nvar EC$1 = elliptic_1.ec;\n\nexport { EC$1 as EC };\n//# sourceMappingURL=elliptic.js.map\n","export var SupportedAlgorithm;\n(function (SupportedAlgorithm) {\n    SupportedAlgorithm[\"sha256\"] = \"sha256\";\n    SupportedAlgorithm[\"sha512\"] = \"sha512\";\n})(SupportedAlgorithm || (SupportedAlgorithm = {}));\n;\n//# sourceMappingURL=types.js.map","export const version = \"solidity/5.6.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { arrayify, concat, hexlify, zeroPad } from \"@ethersproject/bytes\";\nimport { keccak256 as hashKeccak256 } from \"@ethersproject/keccak256\";\nimport { sha256 as hashSha256 } from \"@ethersproject/sha2\";\nimport { toUtf8Bytes } from \"@ethersproject/strings\";\nconst regexBytes = new RegExp(\"^bytes([0-9]+)$\");\nconst regexNumber = new RegExp(\"^(u?int)([0-9]*)$\");\nconst regexArray = new RegExp(\"^(.*)\\\\[([0-9]*)\\\\]$\");\nconst Zeros = \"0000000000000000000000000000000000000000000000000000000000000000\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nfunction _pack(type, value, isArray) {\n    switch (type) {\n        case \"address\":\n            if (isArray) {\n                return zeroPad(value, 32);\n            }\n            return arrayify(value);\n        case \"string\":\n            return toUtf8Bytes(value);\n        case \"bytes\":\n            return arrayify(value);\n        case \"bool\":\n            value = (value ? \"0x01\" : \"0x00\");\n            if (isArray) {\n                return zeroPad(value, 32);\n            }\n            return arrayify(value);\n    }\n    let match = type.match(regexNumber);\n    if (match) {\n        //let signed = (match[1] === \"int\")\n        let size = parseInt(match[2] || \"256\");\n        if ((match[2] && String(size) !== match[2]) || (size % 8 !== 0) || size === 0 || size > 256) {\n            logger.throwArgumentError(\"invalid number type\", \"type\", type);\n        }\n        if (isArray) {\n            size = 256;\n        }\n        value = BigNumber.from(value).toTwos(size);\n        return zeroPad(value, size / 8);\n    }\n    match = type.match(regexBytes);\n    if (match) {\n        const size = parseInt(match[1]);\n        if (String(size) !== match[1] || size === 0 || size > 32) {\n            logger.throwArgumentError(\"invalid bytes type\", \"type\", type);\n        }\n        if (arrayify(value).byteLength !== size) {\n            logger.throwArgumentError(`invalid value for ${type}`, \"value\", value);\n        }\n        if (isArray) {\n            return arrayify((value + Zeros).substring(0, 66));\n        }\n        return value;\n    }\n    match = type.match(regexArray);\n    if (match && Array.isArray(value)) {\n        const baseType = match[1];\n        const count = parseInt(match[2] || String(value.length));\n        if (count != value.length) {\n            logger.throwArgumentError(`invalid array length for ${type}`, \"value\", value);\n        }\n        const result = [];\n        value.forEach(function (value) {\n            result.push(_pack(baseType, value, true));\n        });\n        return concat(result);\n    }\n    return logger.throwArgumentError(\"invalid type\", \"type\", type);\n}\n// @TODO: Array Enum\nexport function pack(types, values) {\n    if (types.length != values.length) {\n        logger.throwArgumentError(\"wrong number of values; expected ${ types.length }\", \"values\", values);\n    }\n    const tight = [];\n    types.forEach(function (type, index) {\n        tight.push(_pack(type, values[index]));\n    });\n    return hexlify(concat(tight));\n}\nexport function keccak256(types, values) {\n    return hashKeccak256(pack(types, values));\n}\nexport function sha256(types, values) {\n    return hashSha256(pack(types, values));\n}\n//# sourceMappingURL=index.js.map"],"sourceRoot":""}