{"matchId":"57386885","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-10-28T12:44:58Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"0x608080604052346100c0575f549060ff8260081c1661006e575060ff80821603610034575b604051612dfc9081620000c58239f35b60ff90811916175f557f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498602060405160ff8152a15f610024565b62461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b6064820152608490fd5b5f80fdfe6080806040526004361015610012575f80fd5b5f3560e01c90816301ffc9a7146123be5750806306fdde0314612328578063081812fc1461230a578063095ea7b31461219657806318160ddd146121795780631fc928ae14612151578063220cce971461212957806323b872dd1461210057806342842e0e146120d957806342ec38e2146120a1578063485cc95514611a0d5780636352211e146119dd5780636c67be49146117d057806370a082311461173b57806395d89b4114611671578063a22cb465146115a3578063b88d4fde14611519578063c87b56dd14610176578063e985e9c5146101245763fbfa77cf146100f8575f80fd5b34610120575f366003190112610120576097546040516001600160a01b039091168152602090f35b5f80fd5b346101205760403660031901126101205761013d61246f565b610145612485565b9060018060a01b038091165f52606a60205260405f2091165f52602052602060ff60405f2054166040519015158152f35b3461012057602080600319360112610120576004355f818152606760205260409020546101ad906001600160a01b0316151561267a565b5f90807a184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000818181101561150b575b5050836d04ee2d6d415b85acef8100000000808410156114fd575b5050662386f26fc10000808310156114ee575b506305f5e100808310156114df575b50612710808310156114d0575b5060648210156114c0575b600a809210156114b6575b60019081602161024860018701612a0a565b95860101905b611481575b5050505061126b61122e6101296113f29360018060a01b03867f227d2c7b2274726169745f74797065223a225661756c74222c2276616c75652261029a8360995416612a3c565b92601c8551115f1461145c5761123d6112336040516102b8816124ec565b60028152610c8d60f21b868201525b61122e610c7a60405180937f3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f32308a8301527f30302f737667222077696474683d223136303022206865696768743d2231363060408301527f30222076696577426f783d2230203020313630302031363030223e3c7265637460608301527f2077696474683d223136303022206865696768743d2231363030222066696c6c60808301527f3d227768697465222f3e3c706174682066696c6c3d222330326135653622206660a08301527f696c6c2d72756c653d226576656e6f646422207472616e73666f726d3d22747260c08301527f616e736c61746528393620313229207363616c65282e3838292220643d224d3760e08301527f39382e302c34342e354c3830302e352c34352e304c3831392e352c3130362e306101008301527f4c3835302e352c3138372e304c3838312e352c3235362e304c3931352e352c336101208301527f32342e304c3939352e352c3436352e304c313131372e352c3636322e304c31316101408301527f35392e352c3733382e304c313138392e352c3739392e304c313231362e352c386101608301527f36362e304c313233352e352c3932382e304c313234392e352c3939352e304c316101808301527f3235352e352c313035312e304c313235332e352c313133392e304c313234382e6101a08301527f352c313137342e304c313233372e352c313232302e304c313232302e352c31326101c08301527f36372e304c313230312e352c313330362e304c313137332e352c313335312e306101e08301527f4c313134362e352c313338362e304c313131382e302c313431362e354c3130376102008301527f392e302c313435302e354c313034352e302c313437342e354c3939382e302c316102208301527f3530302e354c3935392e302c313531372e354c3932322e302c313532392e354c6102408301527f3836362e302c313534312e354c3832342e302c313534352e354c3737322e302c6102608301527f313534352e354c3733332e302c313534312e354c3638312e302c313533302e356102808301527f4c3634362e302c313531392e354c3630372e302c313530332e354c3536322e306102a08301527f2c313437392e354c3532392e302c313435372e354c3439392e302c313433332e6102c08301527f354c3436362e352c313430322e304c3433362e352c313336372e304c3430382e6102e08301527f352c313332362e304c3338322e352c313237372e304c3337302e352c313234386103008301527f2e304c3335332e352c313139312e304c3334362e352c313135332e304c3334336103208301527f2e352c313131392e304c3334352e352c313032392e304c3335352e352c3936336103408301527f2e304c3337312e352c3839382e304c3339382e352c3832352e304c3434322e356103608301527f2c3733332e304c3437342e352c3637342e304c3631362e352c3434332e304c366103808301527f39322e352c3330362e304c3732372e352c3233342e304c3735362e352c3136376103a08301527f2e304c3737372e352c3131322e305a4d3836352e302c3330302e354c3836342e6103c08301527f352c3330372e304c3930342e352c3438322e304c3932362e352c3536312e304c6103e08301527f3934342e352c3631312e304c3936372e352c3635362e304c3938332e302c36376104008301527f342e354c3939352e302c3638332e354c313030382e302c3638392e354c3130326104208301527f362e302c3639312e354c313033362e302c3638382e354c313034332e352c36386104408301527f332e304c313034382e352c3637332e304c313034382e352c3636302e304c31306104608301527f34342e352c3634382e304c313032382e352c3631382e304c3934342e352c34386104808301527f312e304c3932372e352c3434372e304c3932342e352c3434352e304c3838392e6104a08301527f352c3337312e305a4d313033372e302c3735332e354c313032342e302c3735376104c08301527f2e354c313030392e352c3737302e304c313030342e352c3738302e304c3130306104e08301527f322e352c3739362e304c313030382e352c3831342e304c313031392e302c38326105008301527f352e354c313033352e302c3833322e354c313035302e302c3833322e354c31306105208301527f36352e302c3832362e354c313037322e352c3832302e304c313037392e352c386105408301527f30392e304c313038322e352c3739302e304c313037392e352c3737382e304c316105608301527f3037302e302c3736342e354c313035382e302c3735362e355a4d3831382e302c6105808301527f3836352e354c3739362e302c3836372e354c3736332e302c3837362e354c37346105a08301527f382e302c3838332e354c3732392e302c3839362e354c3730392e352c3931372e6105c08301527f304c3730302e352c3933332e304c3639332e352c3935352e304c3639332e352c6105e08301527f3937322e304c3639392e302c3937362e354c3734392e302c3937362e354c37356106008301527f352e352c3937322e304c3736342e352c3935322e304c3738312e302c3933362e6106208301527f354c3830332e302c3932382e354c3833352e302c3932372e354c3835372e302c6106408301527f3933332e354c3836352e302c3933382e354c3837362e352c3935322e304c38386106608301527f322e352c3937332e304c3838322e352c3939392e304c3737362e302c313030376106808301527f2e354c3734382e302c313031342e354c3731382e302c313032392e354c3639336106a08301527f2e352c313035342e304c3638322e352c313037392e304c3637392e352c3131316106c08301527f332e304c3638352e352c313134302e304c3639362e352c313136312e304c37316106e08301527f352e302c313138302e354c3733342e302c313139322e354c3736332e302c31326107008301527f30322e354c3739362e302c313230352e354c3832322e302c313230312e354c386107208301527f35312e302c313138392e354c3838312e302c313136362e354c3838332e352c316107408301527f3139322e304c3838392e302c313139382e354c3934342e302c313139382e354c6107608301527f3934382e352c313139352e304c3935302e352c313138392e304c3935302e352c6107808301527f3937362e304c3934382e352c3935362e304c3934332e352c3933372e304c39326107a08301527f372e352c3930392e304c3931342e302c3839352e354c3839382e302c3838342e6107c08301527f354c3838342e302c3837372e354c3835392e302c3836392e355a4d313031382e6107e08301527f302c3837312e354c313031332e302c3837332e354c313030382e352c3838302e6108008301527f304c313030382e352c313139302e304c313031312e352c313139372e304c31306108208301527f31372e302c313139392e354c313036352e302c313139392e354c313037312e306108408301527f2c313139372e354c313037362e352c313138392e304c313037352e352c3837396108608301527f2e304c313037312e302c3837332e354c313036362e302c3837312e355a4d34336108808301527f322e302c3934322e354c3432332e352c3938352e304c3431372e352c313035316108a08301527f2e304c3431372e352c313039332e304c3432312e352c313134322e304c3433316108c08301527f2e352c313139352e304c3434332e352c313233342e304c3436352e352c3132386108e08301527f322e304c3438352e352c313331342e304c3531342e352c313334392e304c35366109008301527f322e302c313339302e354c3630302e302c313431342e354c3635322e302c31346109208301527f33382e354c3638362e302c313434382e354c3731352e302c313435312e354c376109408301527f35312e302c313434352e354c3738342e302c313432392e354c3830312e352c316109608301527f3431332e304c3830382e352c313339392e304c3830382e352c313338342e304c6109808301527f3830302e302c313337302e354c3738362e302c313336332e354c3734312e302c6109a08301527f313335372e354c3730302e302c313334372e354c3637322e302c313333372e356109c08301527f4c3634312e302c313332322e354c3539342e302c313239302e354c3536332e356109e08301527f2c313236312e304c3534352e352c313233392e304c3531342e352c313139302e610a008301527f304c3438312e352c313131382e304c3435342e352c313033372e304c3433392e610a208301527f352c3937362e304c3433342e352c3934352e305a4d3837362e302c313035352e610a408301527f354c3838322e352c313035372e304c3838312e352c313038362e304c3837372e610a608301527f352c313130302e304c3836392e352c313131342e304c3834362e302c31313334610a808301527f2e354c3832322e302c313134332e354c3739352e302c313134352e354c373638610aa08301527f2e302c313133372e354c3735332e352c313132342e304c3734382e352c313131610ac08301527f322e304c3734382e352c313039342e304c3735352e352c313038302e304c3736610ae08301527f382e302c313036392e354c3738362e302c313036322e354c3830342e302c3130610b008301527f35392e355a4d3538392e302c313132312e354c3537302e302c313133302e354c610b208301527f3536302e352c313134322e304c3535352e352c313135372e304c3535362e352c610b408301527f313137322e304c3536322e352c313138352e304c3537342e302c313139362e35610b608301527f4c3538382e302c313230322e354c3630352e302c313230322e354c3632342e30610b808301527f2c313139332e354c3633332e352c313138322e304c3633382e352c313136352e610ba08301527f304c3633372e352c313135332e304c3633302e352c313133382e304c3631392e610bc08301527f302c313132372e354c3630352e302c313132312e355a222f3e3c746578742078610be08301527f3d223830302220793d22313531352220746578742d616e63686f723d226d6964610c008301527f646c65222066696c6c3d22233032613565362220666f6e742d66616d696c793d610c208301527f226d6f6e6f73706163652220666f6e742d7765696768743d22626f6c64222066610c408301526937b73a16b9b4bd329e9160b11b610c60830152610c6a906111e2815180928d8587019101612429565b62223e2360e81b908301918201528b51998c0199610c6d916c1e17ba32bc3a1f1e17b9bb339f60991b919061121a828583018f612429565b019182015203610c5a810184520182612524565b612b37565b9160975416612a3c565b92604051988996717b226e616d65223a2264726f702e6169202360701b8d8901525180926032890190612429565b85017f222c226465736372697074696f6e223a225472616e7366657261626c6520726560328201527f67697374726174696f6e20726563656970743b20656c69676962696c6974792060528201527f616e642072657761726420686973746f7279207374617920776974682074686560728201527f206f726967696e616c2072656769737472616e742e222c00000000000000000060928201527f22696d616765223a22646174613a696d6167652f7376672b786d6c3b6261736560a9820152620d8d0b60ea1b60c982015261134a825180938d60cc85019101612429565b01927f222c2261747472696275746573223a5b7b2274726169745f74797065223a225060cc8501527f726f6a65637420746f6b656e222c2276616c7565223a2200000000000000000060ec850152610103936113ae825180938d8885019101612429565b0192830152611d1160f11b610123830152610125916113d5825180938b8685019101612429565b019063227d5d7d60e01b9082015203610109810184520182612524565b90611444603d60405180947f646174613a6170706c69636174696f6e2f6a736f6e3b6261736536342c0000008583015261143481518092878686019101612429565b810103601d810185520183612524565b61145860405192828493845283019061244a565b0390f35b61123d61123360405161146e816124ec565b60028152610d8d60f21b868201526102c7565b5f19019083906f181899199a1a9b1b9c1cb0b131b232b360811b8282061a8353049182156114b15791908261024e565b610253565b9160010191610236565b919060646002910491019161022b565b60049193920491019184610220565b60089193920491019184610213565b60109193920491019184610204565b9301929091049083856101f1565b6040945004915084806101d6565b346101205760803660031901126101205761153261246f565b61153a612485565b6064359167ffffffffffffffff831161012057366023840112156101205782600401359161156783612546565b926115756040519485612524565b8084523660248287010111610120576020815f9260246115a198018388013785010152604435916126eb565b005b34610120576040366003190112610120576115bc61246f565b60243590811515809203610120576001600160a01b03169033821461162c57335f52606a60205260405f20825f5260205260405f2060ff1981541660ff83161790556040519081527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3160203392a3005b60405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c6572000000000000006044820152606490fd5b34610120575f366003190112610120576040516066545f8261169283612562565b91828252602093600190856001821691825f1461171b5750506001146116c0575b5061144492500383612524565b84915060665f527f46501879b8ca8525e8c2fd519e2fbfcfa2ebea26501294aa02cbfcfb12e94354905f915b8583106117035750506114449350820101856116b3565b805483890185015287945086939092019181016116ec565b60ff19168582015261144495151560051b85010192508791506116b39050565b34610120576020366003190112610120576001600160a01b0361175c61246f565b168015611779575f526068602052602060405f2054604051908152f35b60405162461bcd60e51b815260206004820152602960248201527f4552433732313a2061646472657373207a65726f206973206e6f7420612076616044820152683634b21037bbb732b960b91b6064820152608490fd5b3461012057602080600319360112610120576117ea61246f565b6098546001600160a01b039190821633036119a957168015801580611996575b1561195857609a545f198114611944576001019081609a55825f52609b84528160405f2055611901575f81815260676020526040902054611857906001600160a01b031615155b1561296b565b5f81815260676020526040902054611879906001600160a01b03161515611851565b815f526068835260405f2060018154019055805f526067835260405f20826bffffffffffffffffffffffff60a01b825416179055806040519281815f7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8180a47ffd1995ad60fcfdd104c7a1a5a012e20956cdefe209014cc852dd3bdeb7b8b58b5f80a38152f35b6064836040519062461bcd60e51b825280600483015260248201527f4552433732313a206d696e7420746f20746865207a65726f20616464726573736044820152fd5b634e487b7160e01b5f52601160045260245ffd5b60405162461bcd60e51b8152600481018490526016602482015275414c52454144595f4d494e5445445f4f525f5a45524f60501b6044820152606490fd5b50815f52609b835260405f20541561180a565b60405162461bcd60e51b815260048101849052600c60248201526b4f4e4c595f5245574152445360a01b6044820152606490fd5b346101205760203660031901126101205760206119fb6004356126c6565b6040516001600160a01b039091168152f35b3461012057604036600319011261012057611a2661246f565b611a2e612485565b905f549060ff8260081c161591828093612094575b801561207d575b156120215760ff1981166001175f5582612010575b5060384603611fd857803b151580611fce575b15611f9a57604051630ac77c9f60e11b81526020816004816001600160a01b0386165afa908115611ebe575f91611f5f575b5080611efe575b15611ec957604051630fe4945760e11b8152926020846004816001600160a01b0386165afa938415611ebe575f94611e8d575b506001600160a01b03841615611e6057611af6612657565b611afe612657565b90611b1860ff5f5460081c16611b138161290b565b61290b565b80519067ffffffffffffffff8211611d5b578190611b37606554612562565b601f8111611dee575b50602090601f8311600114611d7a575f92611d6f575b50508160011b915f199060031b1c1916176065555b80519067ffffffffffffffff8211611d5b578190611b8a606654612562565b601f8111611ced575b50602090601f8311600114611c69575f92611c5e575b50508160011b915f199060031b1c1916176066555b609780546001600160a01b039384166001600160a01b03199182168117909255609880549385169382168417905560998054969094169516851790925560405193917fd7ee11e99cabda2fff26fe0f6f51344d59c5c6b3860082af6d33ec24d0b8e6ee5f80a4611c2a57005b60207f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989161ff00195f54165f5560018152a1005b015190508680611ba9565b60665f9081527f46501879b8ca8525e8c2fd519e2fbfcfa2ebea26501294aa02cbfcfb12e943549350601f198516905b818110611cd55750908460019594939210611cbd575b505050811b01606655611bbe565b01515f1960f88460031b161c19169055868080611caf565b92936020600181928786015181550195019301611c99565b90915060665f527f46501879b8ca8525e8c2fd519e2fbfcfa2ebea26501294aa02cbfcfb12e94354601f840160051c81019160208510611d51575b90601f859493920160051c01905b818110611d435750611b93565b5f8155849350600101611d36565b9091508190611d28565b634e487b7160e01b5f52604160045260245ffd5b015190508780611b56565b925060655f525f80516020612da7833981519152905f935b601f1984168510611dd3576001945083601f19811610611dbb575b505050811b01606555611b6b565b01515f1960f88460031b161c19169055878080611dad565b81810151835560209485019460019093019290910190611d92565b90915060655f52601f830160051c5f80516020612da7833981519152019060208410611e4b575b90601f8493920160051c5f80516020612da783398151915201905b818110611e3d5750611b40565b5f8155849350600101611e30565b5f80516020612da78339815191529150611e15565b60405162461bcd60e51b81526020600482015260056024820152642a27a5a2a760d91b6044820152606490fd5b611eb091945060203d602011611eb7575b611ea88183612524565b810190612638565b9284611ade565b503d611e9e565b6040513d5f823e3d90fd5b60405162461bcd60e51b815260206004820152600d60248201526c5641554c545f42494e44494e4760981b6044820152606490fd5b5060405163220cce9760e01b81526020816004816001600160a01b0386165afa908115611ebe575f91611f40575b506001600160a01b03848116911614611aab565b611f59915060203d602011611eb757611ea88183612524565b84611f2c565b90506020813d602011611f92575b81611f7a60209383612524565b81010312610120575180151581036101205784611aa4565b3d9150611f6d565b60405162461bcd60e51b815260206004820152600c60248201526b42494e44494e475f434f444560a01b6044820152606490fd5b50823b1515611a72565b60405162461bcd60e51b815260206004820152601060248201526f4253435f4d41494e4e45545f4f4e4c5960801b6044820152606490fd5b61ffff1916610101175f5583611a5f565b60405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b6064820152608490fd5b50303b158015611a4a5750600160ff821614611a4a565b50600160ff821610611a43565b34610120576020366003190112610120576001600160a01b036120c261246f565b165f52609b602052602060405f2054604051908152f35b34610120576115a16120ea3661249b565b90604051926120f8846124d0565b5f84526126eb565b34610120576115a16121113661249b565b9161212461211f8433612733565b6125d6565b6127f7565b34610120575f366003190112610120576098546040516001600160a01b039091168152602090f35b34610120575f366003190112610120576099546040516001600160a01b039091168152602090f35b34610120575f366003190112610120576020609a54604051908152f35b34610120576040366003190112610120576121af61246f565b602435906001600160a01b0380806121c6856126c6565b169216918083146122bb5780331490811561229a575b501561222f575f83815260696020526040902080546001600160a01b03191683179055612208836126c6565b167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9255f80a4005b60405162461bcd60e51b815260206004820152603d60248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f60448201527f6b656e206f776e6572206f7220617070726f76656420666f7220616c6c0000006064820152608490fd5b90505f52606a60205260405f20335f5260205260ff60405f205416846121dc565b60405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b6064820152608490fd5b346101205760203660031901126101205760206119fb60043561259a565b34610120575f366003190112610120576040516065545f8261234983612562565b91828252602093600190856001821691825f1461171b575050600114612376575061144492500383612524565b84915060655f525f80516020612da7833981519152905f915b8583106123a65750506114449350820101856116b3565b8054838901850152879450869390920191810161238f565b34610120576020366003190112610120576004359063ffffffff60e01b8216809203610120576020916380ac58cd60e01b8114908115612418575b8115612407575b5015158152f35b6301ffc9a760e01b14905083612400565b635b5e139f60e01b811491506123f9565b5f5b83811061243a5750505f910152565b818101518382015260200161242b565b9060209161246381518092818552858086019101612429565b601f01601f1916010190565b600435906001600160a01b038216820361012057565b602435906001600160a01b038216820361012057565b6060906003190112610120576001600160a01b0390600435828116810361012057916024359081168103610120579060443590565b6020810190811067ffffffffffffffff821117611d5b57604052565b6040810190811067ffffffffffffffff821117611d5b57604052565b6060810190811067ffffffffffffffff821117611d5b57604052565b90601f8019910116810190811067ffffffffffffffff821117611d5b57604052565b67ffffffffffffffff8111611d5b57601f01601f191660200190565b90600182811c92168015612590575b602083101461257c57565b634e487b7160e01b5f52602260045260245ffd5b91607f1691612571565b5f818152606760205260409020546125bc906001600160a01b0316151561267a565b5f908152606960205260409020546001600160a01b031690565b156125dd57565b60405162461bcd60e51b815260206004820152602d60248201527f4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e6560448201526c1c881bdc88185c1c1c9bdd9959609a1b6064820152608490fd5b9081602091031261012057516001600160a01b03811681036101205790565b60405190612664826124ec565b600782526664726f702e616960c81b6020830152565b1561268157565b60405162461bcd60e51b815260206004820152601860248201527f4552433732313a20696e76616c696420746f6b656e20494400000000000000006044820152606490fd5b5f908152606760205260409020546001600160a01b03166126e881151561267a565b90565b9061270f9392916126ff61211f8433612733565b61270a8383836127f7565b612c90565b1561271657565b60405162461bcd60e51b81528061272f600482016129b7565b0390fd5b906001600160a01b038080612747846126c6565b1693169183831493841561277a575b508315612764575b50505090565b6127709192935061259a565b16145f808061275e565b9093505f52606a60205260405f20825f5260205260ff60405f205416925f612756565b156127a457565b60405162461bcd60e51b815260206004820152602560248201527f4552433732313a207472616e736665722066726f6d20696e636f72726563742060448201526437bbb732b960d91b6064820152608490fd5b9061281f91612805846126c6565b6001600160a01b039391841692849290918316841461279d565b169182156128ba578161283c91612835866126c6565b161461279d565b825f52606960205260405f206bffffffffffffffffffffffff60a01b90818154169055815f52606860205260405f205f198154019055825f5260405f2060018154019055835f5260676020528260405f20918254161790557fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef5f80a4565b60405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b6064820152608490fd5b1561291257565b60405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201526a6e697469616c697a696e6760a81b6064820152608490fd5b1561297257565b60405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e746564000000006044820152606490fd5b60809060208152603260208201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b60608201520190565b90612a1482612546565b612a216040519182612524565b8281528092612a32601f1991612546565b0190602036910137565b604051906001600160a01b0316612a5282612508565b602a825260208083016040368237835115612b23576030905382519060019160011015612b235790607860218501536029915b818311612ada57505050612a965790565b606460405162461bcd60e51b815260206004820152602060248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e746044820152fd5b909192600f81166010811015612b23578551851015612b23576f181899199a1a9b1b9c1cb0b131b232b360811b901a85850183015360041c928015611944575f19019190612a85565b634e487b7160e01b5f52603260045260245ffd5b90815115612c7c5760405191612b4c83612508565b604083527f4142434445464748494a4b4c4d4e4f505152535455565758595a61626364656660208401527f6768696a6b6c6d6e6f707172737475767778797a303132333435363738392b2f604084015280519260029160028501809511611944576003948590046001600160fe1b038116810361194457612bd29060029694961b612a0a565b9260208401928291835184019760208901928351945f85525b8a8110612c2f57505050506003939495965052510680600114612c1d57600214612c13575090565b603d905f19015390565b50603d90815f19820153600119015390565b836004919b989b019a8b51600190603f9082828260121c16870101518453828282600c1c16870101518385015382828260061c168701015187850153168401015185820153019699612beb565b9050604051612c8a816124d0565b5f815290565b9293929190803b15612d9d57935f91612ce99560018060a01b039160405194838694928593630a85bd0160e11b998a86523360048701521660248501526044840152608060648401528260209a8b97608483019061244a565b0393165af15f9181612d5d575b50612d4e57833d15612d47573d612d0c81612546565b90612d1a6040519283612524565b81523d5f8383013e5b80519182612d445760405162461bcd60e51b81528061272f600482016129b7565b01fd5b6060612d23565b6001600160e01b031916149150565b9091508481813d8311612d96575b612d758183612524565b8101031261012057516001600160e01b03198116810361012057905f612cf6565b503d612d6b565b5060019350505056fe8ff97419363ffd7000167f130ef7168fbea05faf9251824ca5043f113cc6a7c7a26469706673582212205ae1f288adbb988fe3fb5d1b235840638a5d5778eb6899b446309ac790bb9fa664736f6c63430008180033","sourceMap":"727:6240:21:-:0;;;;;;;6007:13:0;727:6240:21;;;;;;;;;;;;;;6078:31:0;6074:139;;-1:-1:-1;727:6240:21;;;;;;;;;6074:139:0;727:6240:21;;;;;;6007:13:0;727:6240:21;6174:28:0;727:6240:21;;;;;;6174:28:0;6074:139;;;727:6240:21;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212205ae1f288adbb988fe3fb5d1b235840638a5d5778eb6899b446309ac790bb9fa664736f6c63430008180033","offset":11916}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"727:6240:21:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;820:20;727:6240;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;5001:18:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;13872:53:1;;-1:-1:-1;;;;;727:6240:21;7701:31:1;;13872:53;:::i;:::-;727:6240:21;;2829:18;10276:8:19;2829:18:21;10267:17:19;;;;10263:103;;727:6240:21;10392:8:19;;;;10383:17;;;;10379:103;;727:6240:21;10508:8:19;;;10499:17;;;;10495:103;;727:6240:21;10624:7:19;;10615:16;;;;10611:100;;727:6240:21;10737:7:19;;10728:16;;;;10724:100;;727:6240:21;10841:16:19;10850:7;10841:16;;;10837:100;;727:6240:21;10963:7:19;;10954:16;;;10950:66;;727:6240:21;;;;731:76:17;627:18;727:6240:21;;;627:18:17;:::i;:::-;659:11;731:76;;;820:280;727:6240:21;;;820:280:17;727:6240:21;;;;;6429:442;;6936:19;727:6240;;;;;;;;2882:29;727:6240;2902:8;727:6240;;2882:29;:::i;:::-;727:6240;6330:2;727:6240;;6311:21;:35;;;;6826:26;6674:18;727:6240;;;;;:::i;:::-;;;;-1:-1:-1;;;727:6240:21;;;;6311:35;3117:3281;;727:6240;;3117:3281;;727:6240;3117:3281;;;727:6240;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;:::i;:::-;;;;;;3117:3281;;;;;;;;;:::i;:::-;6674:18;:::i;:::-;727:6240;6846:5;727:6240;;6826:26;:::i;:::-;727:6240;;;;;;;;;6429:442;;;727:6240;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;6429:442;;;;;;;;;:::i;6936:19::-;727:6240;;6429:442;727:6240;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;;6311:35;6826:26;6674:18;727:6240;;;;;:::i;:::-;;;;-1:-1:-1;;;727:6240:21;;;;6311:35;;820:280:17;-1:-1:-1;;727:6240:21;;;;-1:-1:-1;;;925:93:17;;;;727:6240:21;925:93:17;727:6240:21;1068:10:17;;;1064:21;;820:280;;;;;1064:21;1080:5;;10950:66:19;727:6240:21;;;10950:66:19;;;10837:100;727:6240:21;;10850:7:19;10921:1;727:6240:21;;;;10837:100:19;;;10724;727:6240:21;;;;;;;10724:100:19;;;;10611;10695:1;727:6240:21;;;;;;10611:100:19;;;;10495:103;10581:2;727:6240:21;;;;;;10495:103:19;;;;10379;727:6240:21;;;;;;;10379:103:19;;;;10263;727:6240:21;;-1:-1:-1;727:6240:21;;-1:-1:-1;10263:103:19;;;;727:6240:21;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;727:6240:21;;965:10:6;13549:17:1;;727:6240:21;;965:10:6;727:6240:21;;13606:18:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13667:41:1;727:6240:21;965:10:6;13667:41:1;;727:6240:21;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;3203:7:1;727:6240:21;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;3203:7:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;-1:-1:-1;727:6240:21;;-1:-1:-1;727:6240:21;;;;;;;-1:-1:-1;;727:6240:21;;;;-1:-1:-1;;;;;727:6240:21;;:::i;:::-;;2510:19:1;;727:6240:21;;;;2592:9:1;727:6240:21;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2232:15;727:6240;-1:-1:-1;;;;;727:6240:21;;;;2218:10;:29;727:6240;;;2283:18;;;;:40;;;727:6240;;;;2371:13;727:6240;-1:-1:-1;;727:6240:21;;;;;;;;2371:13;727:6240;;;;2395:7;727:6240;;;;;;;;;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;9571:58:1;;-1:-1:-1;;;;;727:6240:21;7701:31:1;;9580:16;9579:17;9571:58;:::i;:::-;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;9775:58:1;;-1:-1:-1;;;;;727:6240:21;7701:31:1;;9784:16;7613:126;9775:58;727:6240:21;;;10175:9:1;727:6240:21;;;;;;;;;;;;;;10214:7:1;727:6240:21;;;;;;;;;;;;;;;;;;10251:33:1;;;727:6240:21;10251:33:1;;;;2629:40:21;727:6240;2629:40;;727:6240;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;2283:40;727:6240;;;;2305:7;727:6240;;;;;;2305:18;2283:40;;727:6240;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;3301:14:0;3347:34;;;;;;727:6240:21;3346:108:0;;;;727:6240:21;;;;-1:-1:-1;;727:6240:21;;3551:1:0;727:6240:21;;;;3562:65:0;;727:6240:21;1511:13;1528:2;1511:13;:19;727:6240;;1570:18;;:22;;:50;;;727:6240;;;;;;-1:-1:-1;;;1733:20:21;;727:6240;;;;-1:-1:-1;;;;;727:6240:21;;1733:20;;;;;;;727:6240;1733:20;;;727:6240;1733:60;;;;727:6240;;;;;;-1:-1:-1;;;1838:17:21;;727:6240;;;;;-1:-1:-1;;;;;727:6240:21;;1838:17;;;;;;;727:6240;1838:17;;;727:6240;-1:-1:-1;;;;;;727:6240:21;;1874:19;727:6240;;;;:::i;:::-;;;:::i;:::-;;5366:69:0;727:6240:21;;;;;;5366:69:0;;;:::i;:::-;;:::i;:::-;727:6240:21;;;;;;;;;;;1894:13:1;727:6240:21;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;1894:13:1;727:6240:21;;;;;;;;;;;;;1917:17:1;727:6240:21;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;1917:17:1;727:6240:21;;1960:14;727:6240;;-1:-1:-1;;;;;727:6240:21;;;-1:-1:-1;;;;;;727:6240:21;;;;;;;;1985:26;727:6240;;;;;;;;;;;;2022:16;727:6240;;;;;;;;;;;;;;;;;2054:51;-1:-1:-1;;2054:51:21;3647:99:0;;727:6240:21;3647:99:0;727:6240:21;3721:14:0;727:6240:21;;;;;;;;3551:1:0;727:6240:21;;3721:14:0;727:6240:21;;;;;-1:-1:-1;727:6240:21;;;;;1917:17:1;727:6240:21;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;;;;1917:17:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;;;;;;;;;1917:17:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3551:1:0;727:6240:21;;;;;;-1:-1:-1;727:6240:21;;;;;;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;;;;;;1894:13:1;727:6240:21;;-1:-1:-1;;;;;;;;;;;727:6240:21;;;;-1:-1:-1;;727:6240:21;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;;;;;;;1894:13:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;;;;1894:13:1;727:6240:21;;;;;;;-1:-1:-1;;;;;;;;;;;727:6240:21;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;3551:1:0;727:6240:21;;;;-1:-1:-1;;;;;;;;;;;727:6240:21;-1:-1:-1;727:6240:21;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;1838:17;;;;;727:6240;1838:17;727:6240;1838:17;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;727:6240;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;1733:60;-1:-1:-1;727:6240:21;;-1:-1:-1;;;1757:24:21;;727:6240;;;;-1:-1:-1;;;;;727:6240:21;;1757:24;;;;;;;727:6240;1757:24;;;1733:60;-1:-1:-1;;;;;;727:6240:21;;;;;1757:36;1733:60;;1757:24;;;;727:6240;1757:24;727:6240;1757:24;;;;;;;:::i;:::-;;;;1733:20;;;727:6240;1733:20;;727:6240;1733:20;;;;;;727:6240;1733:20;;;:::i;:::-;;;727:6240;;;;;;;;;;;;1733:20;;;;;;-1:-1:-1;1733:20:21;;727:6240;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;1570:50;1596:20;;;:24;;1570:50;;727:6240;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;3562:65:0;-1:-1:-1;;727:6240:21;;;;;3562:65:0;;;727:6240:21;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;3346:108:0;3426:4;;1713:19:5;:23;3387:66:0;;3346:108;3387:66;727:6240:21;3452:1:0;727:6240:21;;;3436:17:0;3346:108;;3347:34;727:6240:21;3380:1:0;727:6240:21;;;3365:16:0;3347:34;;727:6240:21;;;;;;-1:-1:-1;;727:6240:21;;;;-1:-1:-1;;;;;727:6240:21;;:::i;:::-;;;;1117:42;727:6240;;;;;;;;;;;;;;;;;5570:39:1;727:6240:21;;;:::i;:::-;;;;;;;;:::i;:::-;;;;5570:39:1;:::i;727:6240:21:-;;;;5386:7:1;727:6240:21;;;:::i;:::-;965:10:6;5256:99:1;5264:41;965:10:6;;5264:41:1;:::i;:::-;5256:99;:::i;:::-;5386:7;:::i;727:6240:21:-;;;;;;-1:-1:-1;;727:6240:21;;;;847:30;727:6240;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;884:23;727:6240;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;914:26;727:6240;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;727:6240:21;;4046:34:1;727:6240:21;4046:34:1;:::i;:::-;727:6240:21;;;4098:11:1;;;;727:6240:21;;965:10:6;;4179:21:1;:62;;;;;727:6240:21;;;;;;;;;13194:15:1;727:6240:21;;;;;;;-1:-1:-1;;;;;;727:6240:21;;;;;13247:34:1;727:6240:21;13247:34:1;:::i;:::-;727:6240:21;13238:57:1;727:6240:21;13238:57:1;;727:6240:21;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;4179:62:1;727:6240:21;;;;5001:18:1;727:6240:21;;;;;965:10:6;727:6240:21;;;;;;;;;;4179:62:1;;;727:6240:21;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;727:6240:21;;;;;;3039:5:1;727:6240:21;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;3039:5:1;727:6240:21;;-1:-1:-1;;;;;;;;;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2167:51:1;;;:126;;;;727:6240:21;2167:178:1;;;;727:6240:21;;;;;;;2167:178:1;-1:-1:-1;;;1189:51:8;;-1:-1:-1;2167:178:1;;;:126;-1:-1:-1;;;2234:59:1;;;-1:-1:-1;2167:126:1;;727:6240:21;;;;;;;;-1:-1:-1;;727:6240:21;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;727:6240:21;;;;:::o;:::-;;;;-1:-1:-1;;;;;727:6240:21;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;727:6240:21;;;;;;:::o;:::-;;;;;;;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;727:6240:21;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;4428:167:1;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;13872:53:1;;-1:-1:-1;;;;;727:6240:21;7701:31:1;;13872:53;:::i;:::-;-1:-1:-1;727:6240:21;;;4564:15:1;727:6240:21;;;;;;-1:-1:-1;;;;;727:6240:21;;4428:167:1:o;727:6240:21:-;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;727:6240:21;;;;;;;:::o;:::-;;;;;;;:::i;:::-;;;;-1:-1:-1;;;727:6240:21;;;;:::o;:::-;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;2672:219:1;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;-1:-1:-1;;;;;727:6240:21;2806:56:1;2814:19;;;2806:56;:::i;:::-;2672:219;:::o;5682:276::-;;6977:47;5682:276;;;5804:99;5812:41;965:10:6;;5812:41:1;:::i;5804:99::-;6951:7;;;;;:::i;:::-;6977:47;:::i;:::-;727:6240:21;;;5682:276:1:o;727:6240:21:-;;;-1:-1:-1;;;727:6240:21;;;;;;;;:::i;:::-;;;;7897:272:1;;-1:-1:-1;;;;;727:6240:21;;8022:34:1;7897:272;8022:34;:::i;:::-;727:6240:21;;;8074:16:1;;;;:52;;;;;7897:272;8074:87;;;;;7897:272;8066:96;;;7897:272;:::o;8074:87::-;8130:20;;;;;;:::i;:::-;727:6240:21;8130:31:1;8074:87;;;;;:52;727:6240:21;;;-1:-1:-1;727:6240:21;5001:18:1;727:6240:21;;;-1:-1:-1;727:6240:21;;-1:-1:-1;727:6240:21;;;;;-1:-1:-1;727:6240:21;;;8074:52:1;;;;727:6240:21;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;11783:1225:1;;11872:92;11783:1225;11880:34;;;:::i;:::-;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;11880:42:1;;11872:92;:::i;:::-;727:6240:21;11982:16:1;;;727:6240:21;;12192:34:1;12184:92;12192:34;;;;:::i;:::-;727:6240:21;12192:42:1;12184:92;:::i;:::-;727:6240:21;11996:1:1;727:6240:21;12345:15:1;727:6240:21;;;11996:1:1;727:6240:21;;;;;;;;;;;;11996:1:1;727:6240:21;12813:9:1;727:6240:21;;;11996:1:1;727:6240:21;;;;;;;;;11996:1:1;727:6240:21;;11996:1:1;727:6240:21;12832:1:1;727:6240:21;;;;;;11996:1:1;727:6240:21;12885:7:1;727:6240:21;;;;11996:1:1;727:6240:21;;;;;;;;12922:27:1;11996:1;12922:27;;11783:1225::o;727:6240:21:-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;:::o;:::-;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;:::o;2407:149:17:-;727:6240:21;;;-1:-1:-1;;;;;727:6240:21;;;;:::i;:::-;345:66:16;727:6240:21;;;;;;;;;;;;;;;1975:15:17;;;727:6240:21;;345:66:16;;727:6240:21;345:66:16;727:6240:21;;;;;2000:15:17;727:6240:21;;;2000:15:17;345:66:16;2025:128:17;2058:5;;;;;;2170:10;;;278:18;;2407:149;:::o;278:18::-;;727:6240:21;;;;;278:18:17;;727:6240:21;2141:1:17;278:18;;;727:6240:21;278:18:17;;;727:6240:21;278:18:17;727:6240:21;;;278:18:17;;2065:3;2105:11;;;2113:3;2105:11;;2096:21;;;;;;727:6240:21;;;;;;;-1:-1:-1;;;2096:21:17;;727:6240:21;;;;;2084:33:17;2141:1;727:6240:21;2065:3:17;727:6240:21;;;;-1:-1:-1;;727:6240:21;;2030:26:17;;;727:6240:21;;;;-1:-1:-1;727:6240:21;;2141:1:17;727:6240:21;;-1:-1:-1;727:6240:21;505:3382:16;;727:6240:21;;795:16:16;791:31;;727:6240:21;;;;;;:::i;:::-;;;;;;;;;;;;;;;;1357:1:16;;345:66;1357:1;345:66;;;;;;;1362:1;;727:6240:21;;;-1:-1:-1;;;;;345:66:16;;;;;;1326:39;345:66;1357:1;345:66;;;;1326:39;:::i;:::-;1419:2438;727:6240:21;1419:2438:16;;;;;;;;;;727:6240:21;1419:2438:16;;;;;;810:1;1419:2438;;;;;;;;;;;;1362:1;1419:2438;;;;;;;;1362:1;1419:2438;1362:1;;;1419:2438;;;;3867:13;505:3382;:::o;1419:2438::-;;;-1:-1:-1;;1419:2438:16;;505:3382;:::o;1419:2438::-;-1:-1:-1;1419:2438:16;;;-1:-1:-1;;1419:2438:16;;;-1:-1:-1;;1419:2438:16;;505:3382;:::o;1419:2438::-;;1337:1;1419:2438;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;791:31;727:6240:21;;;;;;;:::i;:::-;810:1:16;727:6240:21;;813:9:16;:::o;14484:853:1:-;;;;;;1713:19:5;;:23;:19;;727:6240:21;-1:-1:-1;727:6240:21;;;;;;;;;;;;;;;;;;;;;14688:82:1;;;;965:10:6;14688:82:1;;;727:6240:21;;;;;;;;;;;;;;;14688:82:1;;727:6240:21;;;;;;;;:::i;:::-;14688:82:1;727:6240:21;;14688:82:1;;-1:-1:-1;;14688:82:1;;;14649:682;-1:-1:-1;14684:595:1;;14898:381;727:6240:21;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;727:6240:21;;;;;;;;14948:18:1;;;727:6240:21;;-1:-1:-1;;;14990:60:1;;727:6240:21;14990:60:1;14688:82;14990:60;;;:::i;14944:321::-;15152:95;;727:6240:21;;;;14684:595:1;-1:-1:-1;;;;;;727:6240:21;14820:62:1;;-1:-1:-1;14813:69:1:o;14688:82::-;;;;;;;;;;;;;;;;;:::i;:::-;;;727:6240:21;;;;;-1:-1:-1;;;;;;727:6240:21;;;;;;14688:82:1;;;;;;;;;14649:682;-1:-1:-1;15316:4:1;;-1:-1:-1;;;15309:11:1:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212205ae1f288adbb988fe3fb5d1b235840638a5d5778eb6899b446309ac790bb9fa664736f6c63430008180033","offset":11719}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x6540b713eba5d65c3d812bad0406a58557fe298c52281bb7df6cde4cbbc99b47","blockNumber":"130234779","transactionIndex":"6","deployer":"0x51C2130d28Df7222b0F037faa3721A4348160F75"},"sources":{"agent/AIDROPRegistrationNFT.sol":{"content":"// SPDX-License-Identifier: MIT\r\npragma solidity ^0.8.24;\r\n\r\nimport {ERC721Upgradeable} from \"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/ERC721Upgradeable.sol\";\r\nimport {Base64} from \"@openzeppelin/contracts@4.9.6/utils/Base64.sol\";\r\nimport {Strings} from \"@openzeppelin/contracts@4.9.6/utils/Strings.sol\";\r\n\r\ninterface IRegistrationVaultSource {\r\n    function initialized() external view returns (bool);\r\n    function taxToken() external view returns (address);\r\n    function rewardsContract() external view returns (address);\r\n}\r\n\r\n/// @notice Transferable ERC-721 receipt, issued once per original registrant and project.\r\n/// @dev Factory deploys the locked implementation and initializes one clone per vault.\r\ncontract AIDROPRegistrationNFT is ERC721Upgradeable {\r\n    using Strings for uint256;\r\n\r\n    address public vault;\r\n    address public rewardsContract;\r\n    address public taxToken;\r\n    uint256 public totalSupply;\r\n    // Historical issuance record; transfers do not change it or allow another registration mint.\r\n    // Current ownership is tracked by ERC-721 ownerOf and balanceOf.\r\n    mapping(address => uint256) public tokenOf;\r\n\r\n    event RegistrationNFTInitialized(address indexed vault, address indexed rewards, address indexed taxToken);\r\n    event RegistrationReceiptMinted(address indexed user, uint256 indexed tokenId);\r\n\r\n    constructor() { _disableInitializers(); }\r\n\r\n    function initialize(address vault_, address rewards_) external initializer {\r\n        require(block.chainid == 56, \"BSC_MAINNET_ONLY\");\r\n        require(vault_.code.length > 0 && rewards_.code.length > 0, \"BINDING_CODE\");\r\n        IRegistrationVaultSource source = IRegistrationVaultSource(vault_);\r\n        require(source.initialized() && source.rewardsContract() == rewards_, \"VAULT_BINDING\");\r\n        address token = source.taxToken();\r\n        require(token != address(0), \"TOKEN\");\r\n        __ERC721_init(\"drop.ai\", \"drop.ai\");\r\n        vault = vault_;\r\n        rewardsContract = rewards_;\r\n        taxToken = token;\r\n        emit RegistrationNFTInitialized(vault_, rewards_, token);\r\n    }\r\n\r\n    function mintForRegistration(address user) external returns (uint256 tokenId) {\r\n        require(msg.sender == rewardsContract, \"ONLY_REWARDS\");\r\n        require(user != address(0) && tokenOf[user] == 0, \"ALREADY_MINTED_OR_ZERO\");\r\n        tokenId = ++totalSupply;\r\n        tokenOf[user] = tokenId;\r\n        // Registration mint also supports smart accounts without ERC721Receiver.\r\n        // This mint deliberately does not call user-controlled receiver hooks.\r\n        _mint(user, tokenId);\r\n        emit RegistrationReceiptMinted(user, tokenId);\r\n    }\r\n\r\n    function tokenURI(uint256 tokenId) public view override returns (string memory) {\r\n        _requireMinted(tokenId);\r\n        string memory id = tokenId.toString();\r\n        string memory project = Strings.toHexString(taxToken);\r\n        // Pure on-chain vector artwork, traced from the supplied blue water-drop logo.\r\n        // No image URL, external font, embedded raster or off-chain fetch is needed.\r\n        bytes memory svg = abi.encodePacked(\r\n            '<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1600\" height=\"1600\" viewBox=\"0 0 1600 1600\"><rect width=\"1600\" height=\"1600\" fill=\"white\"/><path fill=\"#02a5e6\" fill-rule=\"evenodd\" transform=\"translate(96 12) scale(.88)\" d=\"M798.0,44.5L800.5,45.0L819.5,106.0L850.5,187.0L881.5,256.0L915.5,324.0L995.5,465.0L1117.5,662.0L1159.5,738.0L1189.5,799.0L1216.5,866.0L1235.5,928.0L1249.5,995.0L1255.5,1051.0L1253.5,1139.0L1248.5,1174.0L1237.5,1220.0L1220.5,1267.0L1201.5,1306.0L1173.5,1351.0L1146.5,1386.0L1118.0,1416.5L1079.0,1450.5L1045.0,1474.5L998.0,1500.5L959.0,1517.5L922.0,1529.5L866.0,1541.5L824.0,1545.5L772.0,1545.5L733.0,1541.5L681.0,1530.5L646.0,1519.5L607.0,1503.5L562.0,1479.5L529.0,1457.5L499.0,1433.5L466.5,1402.0L436.5,1367.0L408.5,1326.0L382.5,1277.0L370.5,1248.0L353.5,1191.0L346.5,1153.0L343.5,1119.0L345.5,1029.0L355.5,963.0L371.5,898.0L398.5,825.0L442.5,733.0L474.5,674.0L616.5,443.0L692.5,306.0L727.5,234.0L756.5,167.0L777.5,112.0ZM865.0,300.5L864.5,307.0L904.5,482.0L926.5,561.0L944.5,611.0L967.5,656.0L983.0,674.5L995.0,683.5L1008.0,689.5L1026.0,691.5L1036.0,688.5L1043.5,683.0L1048.5,673.0L1048.5,660.0L1044.5,648.0L1028.5,618.0L944.5,481.0L927.5,447.0L924.5,445.0L889.5,371.0ZM1037.0,753.5L1024.0,757.5L1009.5,770.0L1004.5,780.0L1002.5,796.0L1008.5,814.0L1019.0,825.5L1035.0,832.5L1050.0,832.5L1065.0,826.5L1072.5,820.0L1079.5,809.0L1082.5,790.0L1079.5,778.0L1070.0,764.5L1058.0,756.5ZM818.0,865.5L796.0,867.5L763.0,876.5L748.0,883.5L729.0,896.5L709.5,917.0L700.5,933.0L693.5,955.0L693.5,972.0L699.0,976.5L749.0,976.5L755.5,972.0L764.5,952.0L781.0,936.5L803.0,928.5L835.0,927.5L857.0,933.5L865.0,938.5L876.5,952.0L882.5,973.0L882.5,999.0L776.0,1007.5L748.0,1014.5L718.0,1029.5L693.5,1054.0L682.5,1079.0L679.5,1113.0L685.5,1140.0L696.5,1161.0L715.0,1180.5L734.0,1192.5L763.0,1202.5L796.0,1205.5L822.0,1201.5L851.0,1189.5L881.0,1166.5L883.5,1192.0L889.0,1198.5L944.0,1198.5L948.5,1195.0L950.5,1189.0L950.5,976.0L948.5,956.0L943.5,937.0L927.5,909.0L914.0,895.5L898.0,884.5L884.0,877.5L859.0,869.5ZM1018.0,871.5L1013.0,873.5L1008.5,880.0L1008.5,1190.0L1011.5,1197.0L1017.0,1199.5L1065.0,1199.5L1071.0,1197.5L1076.5,1189.0L1075.5,879.0L1071.0,873.5L1066.0,871.5ZM432.0,942.5L423.5,985.0L417.5,1051.0L417.5,1093.0L421.5,1142.0L431.5,1195.0L443.5,1234.0L465.5,1282.0L485.5,1314.0L514.5,1349.0L562.0,1390.5L600.0,1414.5L652.0,1438.5L686.0,1448.5L715.0,1451.5L751.0,1445.5L784.0,1429.5L801.5,1413.0L808.5,1399.0L808.5,1384.0L800.0,1370.5L786.0,1363.5L741.0,1357.5L700.0,1347.5L672.0,1337.5L641.0,1322.5L594.0,1290.5L563.5,1261.0L545.5,1239.0L514.5,1190.0L481.5,1118.0L454.5,1037.0L439.5,976.0L434.5,945.0ZM876.0,1055.5L882.5,1057.0L881.5,1086.0L877.5,1100.0L869.5,1114.0L846.0,1134.5L822.0,1143.5L795.0,1145.5L768.0,1137.5L753.5,1124.0L748.5,1112.0L748.5,1094.0L755.5,1080.0L768.0,1069.5L786.0,1062.5L804.0,1059.5ZM589.0,1121.5L570.0,1130.5L560.5,1142.0L555.5,1157.0L556.5,1172.0L562.5,1185.0L574.0,1196.5L588.0,1202.5L605.0,1202.5L624.0,1193.5L633.5,1182.0L638.5,1165.0L637.5,1153.0L630.5,1138.0L619.0,1127.5L605.0,1121.5Z\"/><text x=\"800\" y=\"1515\" text-anchor=\"middle\" fill=\"#02a5e6\" font-family=\"monospace\" font-weight=\"bold\" font-size=\"',\r\n            bytes(id).length > 28 ? '24' : '64',\r\n            '\">#', id, '</text></svg>'\r\n        );\r\n        bytes memory json = abi.encodePacked(\r\n            '{\"name\":\"drop.ai #', id,\r\n            '\",\"description\":\"Transferable registration receipt; eligibility and reward history stay with the original registrant.\",',\r\n            '\"image\":\"data:image/svg+xml;base64,', Base64.encode(svg),\r\n            '\",\"attributes\":[{\"trait_type\":\"Project token\",\"value\":\"', project,\r\n            '\"},{\"trait_type\":\"Vault\",\"value\":\"', Strings.toHexString(vault), '\"}]}'\r\n        );\r\n        return string.concat(\"data:application/json;base64,\", Base64.encode(json));\r\n    }\r\n}\r\n"},"@openzeppelin/contracts@4.9.6/utils/Base64.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.6) (utils/Base64.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides a set of functions to operate with Base64 strings.\n *\n * _Available since v4.5._\n */\nlibrary Base64 {\n    /**\n     * @dev Base64 Encoding/Decoding Table\n     */\n    string internal constant _TABLE = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n    /**\n     * @dev Converts a `bytes` to its Bytes64 `string` representation.\n     */\n    function encode(bytes memory data) internal pure returns (string memory) {\n        /**\n         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence\n         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol\n         */\n        if (data.length == 0) return \"\";\n\n        // Loads the table into memory\n        string memory table = _TABLE;\n\n        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter\n        // and split into 4 numbers of 6 bits.\n        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up\n        // - `data.length + 2`  -> Round up\n        // - `/ 3`              -> Number of 3-bytes chunks\n        // - `4 *`              -> 4 characters for each chunk\n        string memory result = new string(4 * ((data.length + 2) / 3));\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Prepare the lookup table (skip the first \"length\" byte)\n            let tablePtr := add(table, 1)\n\n            // Prepare result pointer, jump over length\n            let resultPtr := add(result, 0x20)\n            let dataPtr := data\n            let endPtr := add(data, mload(data))\n\n            // In some cases, the last iteration will read bytes after the end of the data. We cache the value, and\n            // set it to zero to make sure no dirty bytes are read in that section.\n            let afterPtr := add(endPtr, 0x20)\n            let afterCache := mload(afterPtr)\n            mstore(afterPtr, 0x00)\n\n            // Run over the input, 3 bytes at a time\n            for {\n\n            } lt(dataPtr, endPtr) {\n\n            } {\n                // Advance 3 bytes\n                dataPtr := add(dataPtr, 3)\n                let input := mload(dataPtr)\n\n                // To write each character, shift the 3 byte (24 bits) chunk\n                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)\n                // and apply logical AND with 0x3F to bitmask the least significant 6 bits.\n                // Use this as an index into the lookup table, mload an entire word\n                // so the desired character is in the least significant byte, and\n                // mstore8 this least significant byte into the result and continue.\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n            }\n\n            // Reset the value that was cached\n            mstore(afterPtr, afterCache)\n\n            // When data `bytes` is not exactly 3 bytes long\n            // it is padded with `=` characters at the end\n            switch mod(mload(data), 3)\n            case 1 {\n                mstore8(sub(resultPtr, 1), 0x3d)\n                mstore8(sub(resultPtr, 2), 0x3d)\n            }\n            case 2 {\n                mstore8(sub(resultPtr, 1), 0x3d)\n            }\n        }\n\n        return result;\n    }\n}\n"},"@openzeppelin/contracts@4.9.6/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\nimport \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value))));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts@4.9.6/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"@openzeppelin/contracts@4.9.6/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/AddressUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/StringsUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/MathUpgradeable.sol\";\nimport \"./math/SignedMathUpgradeable.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = MathUpgradeable.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMathUpgradeable.abs(value))));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized != type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/MathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary MathUpgradeable {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/ERC721Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC721Upgradeable.sol\";\nimport \"./IERC721ReceiverUpgradeable.sol\";\nimport \"./extensions/IERC721MetadataUpgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../utils/StringsUpgradeable.sol\";\nimport \"../../utils/introspection/ERC165Upgradeable.sol\";\nimport {Initializable} from \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\n    using AddressUpgradeable for address;\n    using StringsUpgradeable for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    // Mapping from token ID to owner address\n    mapping(uint256 => address) private _owners;\n\n    // Mapping owner address to token count\n    mapping(address => uint256) private _balances;\n\n    // Mapping from token ID to approved address\n    mapping(uint256 => address) private _tokenApprovals;\n\n    // Mapping from owner to operator approvals\n    mapping(address => mapping(address => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {\n        __ERC721_init_unchained(name_, symbol_);\n    }\n\n    function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\n        return\n            interfaceId == type(IERC721Upgradeable).interfaceId ||\n            interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev See {IERC721-balanceOf}.\n     */\n    function balanceOf(address owner) public view virtual override returns (uint256) {\n        require(owner != address(0), \"ERC721: address zero is not a valid owner\");\n        return _balances[owner];\n    }\n\n    /**\n     * @dev See {IERC721-ownerOf}.\n     */\n    function ownerOf(uint256 tokenId) public view virtual override returns (address) {\n        address owner = _ownerOf(tokenId);\n        require(owner != address(0), \"ERC721: invalid token ID\");\n        return owner;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-name}.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-symbol}.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-tokenURI}.\n     */\n    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\n        _requireMinted(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /**\n     * @dev See {IERC721-approve}.\n     */\n    function approve(address to, uint256 tokenId) public virtual override {\n        address owner = ERC721Upgradeable.ownerOf(tokenId);\n        require(to != owner, \"ERC721: approval to current owner\");\n\n        require(\n            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),\n            \"ERC721: approve caller is not token owner or approved for all\"\n        );\n\n        _approve(to, tokenId);\n    }\n\n    /**\n     * @dev See {IERC721-getApproved}.\n     */\n    function getApproved(uint256 tokenId) public view virtual override returns (address) {\n        _requireMinted(tokenId);\n\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev See {IERC721-setApprovalForAll}.\n     */\n    function setApprovalForAll(address operator, bool approved) public virtual override {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /**\n     * @dev See {IERC721-isApprovedForAll}.\n     */\n    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /**\n     * @dev See {IERC721-transferFrom}.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) public virtual override {\n        //solhint-disable-next-line max-line-length\n        require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: caller is not token owner or approved\");\n\n        _transfer(from, to, tokenId);\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {\n        require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: caller is not token owner or approved\");\n        _safeTransfer(from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        require(_checkOnERC721Received(from, to, tokenId, data), \"ERC721: transfer to non ERC721Receiver implementer\");\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `tokenId` exists.\n     *\n     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\n     *\n     * Tokens start existing when they are minted (`_mint`),\n     * and stop existing when they are burned (`_burn`).\n     */\n    function _exists(uint256 tokenId) internal view virtual returns (bool) {\n        return _ownerOf(tokenId) != address(0);\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `tokenId`.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\n        address owner = ERC721Upgradeable.ownerOf(tokenId);\n        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Safely mints `tokenId` and transfers it to `to`.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal virtual {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        require(\n            _checkOnERC721Received(address(0), to, tokenId, data),\n            \"ERC721: transfer to non ERC721Receiver implementer\"\n        );\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal virtual {\n        require(to != address(0), \"ERC721: mint to the zero address\");\n        require(!_exists(tokenId), \"ERC721: token already minted\");\n\n        _beforeTokenTransfer(address(0), to, tokenId, 1);\n\n        // Check that tokenId was not minted by `_beforeTokenTransfer` hook\n        require(!_exists(tokenId), \"ERC721: token already minted\");\n\n        unchecked {\n            // Will not overflow unless all 2**256 token ids are minted to the same owner.\n            // Given that tokens are minted one by one, it is impossible in practice that\n            // this ever happens. Might change if we allow batch minting.\n            // The ERC fails to describe this case.\n            _balances[to] += 1;\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(address(0), to, tokenId);\n\n        _afterTokenTransfer(address(0), to, tokenId, 1);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal virtual {\n        address owner = ERC721Upgradeable.ownerOf(tokenId);\n\n        _beforeTokenTransfer(owner, address(0), tokenId, 1);\n\n        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook\n        owner = ERC721Upgradeable.ownerOf(tokenId);\n\n        // Clear approvals\n        delete _tokenApprovals[tokenId];\n\n        unchecked {\n            // Cannot overflow, as that would require more tokens to be burned/transferred\n            // out than the owner initially received through minting and transferring in.\n            _balances[owner] -= 1;\n        }\n        delete _owners[tokenId];\n\n        emit Transfer(owner, address(0), tokenId);\n\n        _afterTokenTransfer(owner, address(0), tokenId, 1);\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal virtual {\n        require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer from incorrect owner\");\n        require(to != address(0), \"ERC721: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, tokenId, 1);\n\n        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook\n        require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer from incorrect owner\");\n\n        // Clear approvals from the previous owner\n        delete _tokenApprovals[tokenId];\n\n        unchecked {\n            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:\n            // `from`'s balance is the number of token held, which is at least one before the current\n            // transfer.\n            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require\n            // all 2**256 token ids to be minted, which in practice is impossible.\n            _balances[from] -= 1;\n            _balances[to] += 1;\n        }\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        _afterTokenTransfer(from, to, tokenId, 1);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * Emits an {Approval} event.\n     */\n    function _approve(address to, uint256 tokenId) internal virtual {\n        _tokenApprovals[tokenId] = to;\n        emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        require(owner != operator, \"ERC721: approve to caller\");\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` has not been minted yet.\n     */\n    function _requireMinted(uint256 tokenId) internal view virtual {\n        require(_exists(tokenId), \"ERC721: invalid token ID\");\n    }\n\n    /**\n     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\n     * The call is not executed if the target address is not a contract.\n     *\n     * @param from address representing the previous owner of the given token ID\n     * @param to target address that will receive the tokens\n     * @param tokenId uint256 ID of the token to be transferred\n     * @param data bytes optional data to send along with the call\n     * @return bool whether the call correctly returned the expected magic value\n     */\n    function _checkOnERC721Received(\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes memory data\n    ) private returns (bool) {\n        if (to.isContract()) {\n            try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {\n                return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    revert(\"ERC721: transfer to non ERC721Receiver implementer\");\n                } else {\n                    /// @solidity memory-safe-assembly\n                    assembly {\n                        revert(add(32, reason), mload(reason))\n                    }\n                }\n            }\n        } else {\n            return true;\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is\n     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.\n     *\n     * Calling conditions:\n     *\n     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.\n     * - When `from` is zero, the tokens will be minted for `to`.\n     * - When `to` is zero, ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     * - `batchSize` is non-zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is\n     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.\n     *\n     * Calling conditions:\n     *\n     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.\n     * - When `from` is zero, the tokens were minted for `to`.\n     * - When `to` is zero, ``from``'s tokens were burned.\n     * - `from` and `to` are never both zero.\n     * - `batchSize` is non-zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant\n     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such\n     * that `ownerOf(tokenId)` is `a`.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function __unsafe_increaseBalance(address account, uint256 amount) internal {\n        _balances[account] += amount;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[44] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165Upgradeable.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721Upgradeable is IERC165Upgradeable {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the caller.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/SignedMathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMathUpgradeable {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/ERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport {Initializable} from \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n    function __ERC165_init() internal onlyInitializing {\n    }\n\n    function __ERC165_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165Upgradeable).interfaceId;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/IERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721ReceiverUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721ReceiverUpgradeable {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/extensions/IERC721MetadataUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721Upgradeable.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.24+commit.e11b9ed9","compilerSettings":{"viaIR":true,"optimizer":{"runs":200,"enabled":true},"remappings":[]},"name":"AIDROPRegistrationNFT","fullyQualifiedName":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"ApprovalForAll","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"operator","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"name":"RegistrationNFTInitialized","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"rewards","type":"address","indexed":true,"internalType":"address"},{"name":"taxToken","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RegistrationReceiptMinted","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"approve","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"vault_","type":"address","internalType":"address"},{"name":"rewards_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isApprovedForAll","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mintForRegistration","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"}],"outputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"rewardsContract","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setApprovalForAll","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"approved","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"taxToken","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"tokenOf","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"vault","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.24+commit.e11b9ed9"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":true,"internalType":"address","name":"rewards","type":"address"},{"indexed":true,"internalType":"address","name":"taxToken","type":"address"}],"name":"RegistrationNFTInitialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"RegistrationReceiptMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault_","type":"address"},{"internalType":"address","name":"rewards_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"mintForRegistration","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}],"devdoc":{"details":"Factory deploys the locked implementation and initializes one clone per vault.","events":{"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."},"Initialized(uint8)":{"details":"Triggered when the contract has been initialized or reinitialized."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."}},"kind":"dev","methods":{"approve(address,uint256)":{"details":"See {IERC721-approve}."},"balanceOf(address)":{"details":"See {IERC721-balanceOf}."},"getApproved(uint256)":{"details":"See {IERC721-getApproved}."},"isApprovedForAll(address,address)":{"details":"See {IERC721-isApprovedForAll}."},"name()":{"details":"See {IERC721Metadata-name}."},"ownerOf(uint256)":{"details":"See {IERC721-ownerOf}."},"safeTransferFrom(address,address,uint256)":{"details":"See {IERC721-safeTransferFrom}."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"See {IERC721-safeTransferFrom}."},"setApprovalForAll(address,bool)":{"details":"See {IERC721-setApprovalForAll}."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"symbol()":{"details":"See {IERC721Metadata-symbol}."},"tokenURI(uint256)":{"details":"See {IERC721Metadata-tokenURI}."},"transferFrom(address,address,uint256)":{"details":"See {IERC721-transferFrom}."}},"version":1},"userdoc":{"kind":"user","methods":{},"notice":"Transferable ERC-721 receipt, issued once per original registrant and project.","version":1}},"settings":{"compilationTarget":{"agent/AIDROPRegistrationNFT.sol":"AIDROPRegistrationNFT"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[],"viaIR":true},"sources":{"@openzeppelin/contracts-upgradeable@4.9.6/proxy/utils/Initializable.sol":{"keccak256":"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794","license":"MIT","urls":["bzz-raw://f103ee2e4aecd37aac6ceefe670709cdd7613dee25fa2d4d9feaf7fc0aaa155e","dweb:/ipfs/QmRiNZLoJk5k3HPMYGPGjZFd2ke1ZxjhJZkM45Ec9GH9hv"]},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/ERC721Upgradeable.sol":{"keccak256":"0xd6e2dc520133229f192493fc0a53c0cfb0cbcee1e45bf0817c34e416486d9359","license":"MIT","urls":["bzz-raw://2bda0b8ba2463ef7a8d1189ce54139691f5986aab83a3c502614dd2f29996fe8","dweb:/ipfs/QmapEyXhDZCJL4ho7BQMmZUHtkhyJzABn4iWxyJYae1Kom"]},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721ReceiverUpgradeable.sol":{"keccak256":"0xbb2ed8106d94aeae6858e2551a1e7174df73994b77b13ebd120ccaaef80155f5","license":"MIT","urls":["bzz-raw://8bc3c6a456dba727d8dd9fd33420febede490abb49a07469f61d2a3ace66a95a","dweb:/ipfs/QmVAWtEVj7K5AbvgJa9Dz22KiDq9eoptCjnVZqsTMtKXyd"]},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721Upgradeable.sol":{"keccak256":"0xbe63437e37e32162d5d11ea8f11a44378c092b4bcbb05b51a813fe4bf33297d4","license":"MIT","urls":["bzz-raw://68a514febde6ffd8afe3cb5b40815d10c0a926063237d5d167cbaa90239f75ae","dweb:/ipfs/QmVBvYeR6oGBw7K7vu5FMotr8josejtaGwugM68VTZacww"]},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/extensions/IERC721MetadataUpgradeable.sol":{"keccak256":"0x95a471796eb5f030fdc438660bebec121ad5d063763e64d92376ffb4b5ce8b70","license":"MIT","urls":["bzz-raw://4ffbd627e6958983d288801acdedbf3491ee0ebf1a430338bce47c96481ce9e3","dweb:/ipfs/QmUM1vpmNgBV34sYf946SthDJNGhwwqjoRggmj4TUUQmdB"]},"@openzeppelin/contracts-upgradeable@4.9.6/utils/AddressUpgradeable.sol":{"keccak256":"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422","license":"MIT","urls":["bzz-raw://310136ad60820af4177a11a61d77a3686faf5fca4942b600e08fc940db38396b","dweb:/ipfs/QmbCzMNSTL7Zi7M4UCSqBrkHtp4jjxUnGbkneCZKdR1qeq"]},"@openzeppelin/contracts-upgradeable@4.9.6/utils/ContextUpgradeable.sol":{"keccak256":"0x75097e35253e7fb282ee4d7f27a80eaacfa759923185bf17302a89cbc059c5ef","license":"MIT","urls":["bzz-raw://8b06267c5f80bad727af3e48b1382333d591dad51376399ef2f6b0ee6d58bf95","dweb:/ipfs/QmdU5La1agcQvghnfMpWZGDPz2TUDTCxUwTLKmuMRXBpAx"]},"@openzeppelin/contracts-upgradeable@4.9.6/utils/StringsUpgradeable.sol":{"keccak256":"0xb96dc79b65b7c37937919dcdb356a969ce0aa2e8338322bf4dc027a3c9c9a7eb","license":"MIT","urls":["bzz-raw://f8613145881436fc0480fff22da4868d611e2b0c0c3da083334eb4362ce1945a","dweb:/ipfs/QmPqpP3YeRbBdTJRe6Gv2eGsUaANf4J6RwTNRW36iYahfV"]},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/ERC165Upgradeable.sol":{"keccak256":"0xd90d7723512df65ae417adaf0801042940f0dabd60039ceeaffe34aa5b238da1","license":"MIT","urls":["bzz-raw://1b13befeb3413749292f9fb229de1c7a509a5ce2c8047d9094fc004ca9d3af89","dweb:/ipfs/QmRzJ2hZSwRtMejHUZAYTPRKgZsnfb112Fno9Jf3EiDfwA"]},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/IERC165Upgradeable.sol":{"keccak256":"0xc6cef87559d0aeffdf0a99803de655938a7779ec0a3cd5d4383483ad85565a09","license":"MIT","urls":["bzz-raw://92ad7e572cf44e6b4b37631b44b62f9eb9fb1cf14d9ce51c1504d5dc7ccaf758","dweb:/ipfs/QmcnbqX85tsWnUXPmtuPLE4SczME2sJaTfmqEFkuAJvWhy"]},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/MathUpgradeable.sol":{"keccak256":"0x2bc0007987c229ae7624eb29be6a9b84f6a6a5872f76248b15208b131ea41c4e","license":"MIT","urls":["bzz-raw://2b2835c737d073ef8b82a4cc246495a9740f43e7ff2cf130906b2449ff9bfb91","dweb:/ipfs/QmSCWfNoSvvTN57ic7o1RW6NqSxxGAqbBTnLKc7QHe27qB"]},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/SignedMathUpgradeable.sol":{"keccak256":"0x88f6b7bba3ee33eeb741f9a0f5bc98b6e6e352d0fe4905377bb328590f84095a","license":"MIT","urls":["bzz-raw://88ace2d60f265752f18903d839910be4e4e104340b2957678585b812447825d4","dweb:/ipfs/QmXFkNxMc3AAGzhs2wUEZyErWQjsvoTGyYjuU5oZkFki5Z"]},"@openzeppelin/contracts@4.9.6/utils/Base64.sol":{"keccak256":"0x822fe67e9e671773d29c8182e7287b42edf5f575eab1eb98558d5ccbdff61c96","license":"MIT","urls":["bzz-raw://7ce73cb57d5a2e705a0a65cac2ed73ab2fa91932e8af22b7ec1a6a3d88f28669","dweb:/ipfs/QmcbjWFekUTsNeoFwGgUT4xtXoVzsA38ca9pkC4jxvxy7L"]},"@openzeppelin/contracts@4.9.6/utils/Strings.sol":{"keccak256":"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0","license":"MIT","urls":["bzz-raw://b81d9ff6559ea5c47fc573e17ece6d9ba5d6839e213e6ebc3b4c5c8fe4199d7f","dweb:/ipfs/QmPCW1bFisUzJkyjroY3yipwfism9RRCigCcK1hbXtVM8n"]},"@openzeppelin/contracts@4.9.6/utils/math/Math.sol":{"keccak256":"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3","license":"MIT","urls":["bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c","dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS"]},"@openzeppelin/contracts@4.9.6/utils/math/SignedMath.sol":{"keccak256":"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc","license":"MIT","urls":["bzz-raw://c50fcc459e49a9858b6d8ad5f911295cb7c9ab57567845a250bf0153f84a95c7","dweb:/ipfs/QmcEW85JRzvDkQggxiBBLVAasXWdkhEysqypj9EaB6H2g6"]},"agent/AIDROPRegistrationNFT.sol":{"keccak256":"0xd854a58ffa2521a0d5445f8a367a0c8f9f337b49d8da9a99e37480b211748859","license":"MIT","urls":["bzz-raw://aedd23d4fefcd6b441b55b97b8b63b34cc04a1385000611010132ec60fbffc8d","dweb:/ipfs/QmUkECeictRRPgSpxo7nyHDN3zXn1TQv9sktH8va44pZhz"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint8":{"label":"uint8","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_array(t_uint256)44_storage":{"base":"t_uint256","label":"uint256[44]","encoding":"inplace","numberOfBytes":"1408"},"t_array(t_uint256)50_storage":{"base":"t_uint256","label":"uint256[50]","encoding":"inplace","numberOfBytes":"1600"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_address)":{"key":"t_uint256","label":"mapping(uint256 => address)","value":"t_address","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_bool))":{"key":"t_address","label":"mapping(address => mapping(address => bool))","value":"t_mapping(t_address,t_bool)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint8","astId":6,"label":"_initialized","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"0","type":"t_bool","astId":9,"label":"_initializing","offset":1,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"1","type":"t_array(t_uint256)50_storage","astId":1662,"label":"__gap","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"51","type":"t_array(t_uint256)50_storage","astId":1936,"label":"__gap","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"101","type":"t_string_storage","astId":198,"label":"_name","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"102","type":"t_string_storage","astId":200,"label":"_symbol","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"103","type":"t_mapping(t_uint256,t_address)","astId":204,"label":"_owners","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"104","type":"t_mapping(t_address,t_uint256)","astId":208,"label":"_balances","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"105","type":"t_mapping(t_uint256,t_address)","astId":212,"label":"_tokenApprovals","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"106","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":218,"label":"_operatorApprovals","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"107","type":"t_array(t_uint256)44_storage","astId":1120,"label":"__gap","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"151","type":"t_address","astId":5031,"label":"vault","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"152","type":"t_address","astId":5033,"label":"rewardsContract","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"153","type":"t_address","astId":5035,"label":"taxToken","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"154","type":"t_uint256","astId":5037,"label":"totalSupply","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"155","type":"t_mapping(t_address,t_uint256)","astId":5041,"label":"tokenOf","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"Transferable ERC-721 receipt, issued once per original registrant and project.","methods":{},"version":1},"devdoc":{"kind":"dev","events":{"Initialized(uint8)":{"details":"Triggered when the contract has been initialized or reinitialized."},"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."}},"details":"Factory deploys the locked implementation and initializes one clone per vault.","methods":{"name()":{"details":"See {IERC721Metadata-name}."},"symbol()":{"details":"See {IERC721Metadata-symbol}."},"ownerOf(uint256)":{"details":"See {IERC721-ownerOf}."},"tokenURI(uint256)":{"details":"See {IERC721Metadata-tokenURI}."},"balanceOf(address)":{"details":"See {IERC721-balanceOf}."},"getApproved(uint256)":{"details":"See {IERC721-getApproved}."},"approve(address,uint256)":{"details":"See {IERC721-approve}."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"setApprovalForAll(address,bool)":{"details":"See {IERC721-setApprovalForAll}."},"isApprovedForAll(address,address)":{"details":"See {IERC721-isApprovedForAll}."},"transferFrom(address,address,uint256)":{"details":"See {IERC721-transferFrom}."},"safeTransferFrom(address,address,uint256)":{"details":"See {IERC721-safeTransferFrom}."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"See {IERC721-safeTransferFrom}."}},"version":1},"sourceIds":{"agent/AIDROPRegistrationNFT.sol":{"id":21},"@openzeppelin/contracts@4.9.6/utils/Base64.sol":{"id":16},"@openzeppelin/contracts@4.9.6/utils/Strings.sol":{"id":17},"@openzeppelin/contracts@4.9.6/utils/math/Math.sol":{"id":19},"@openzeppelin/contracts@4.9.6/utils/math/SignedMath.sol":{"id":20},"@openzeppelin/contracts-upgradeable@4.9.6/utils/AddressUpgradeable.sol":{"id":5},"@openzeppelin/contracts-upgradeable@4.9.6/utils/ContextUpgradeable.sol":{"id":6},"@openzeppelin/contracts-upgradeable@4.9.6/utils/StringsUpgradeable.sol":{"id":7},"@openzeppelin/contracts-upgradeable@4.9.6/proxy/utils/Initializable.sol":{"id":0},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/MathUpgradeable.sol":{"id":10},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/ERC721Upgradeable.sol":{"id":1},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721Upgradeable.sol":{"id":3},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/SignedMathUpgradeable.sol":{"id":11},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/ERC165Upgradeable.sol":{"id":8},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/IERC165Upgradeable.sol":{"id":9},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721ReceiverUpgradeable.sol":{"id":2},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/extensions/IERC721MetadataUpgradeable.sol":{"id":4}},"additionalInput":null,"stdJsonInput":{"sources":{"agent/AIDROPRegistrationNFT.sol":{"content":"// SPDX-License-Identifier: MIT\r\npragma solidity ^0.8.24;\r\n\r\nimport {ERC721Upgradeable} from \"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/ERC721Upgradeable.sol\";\r\nimport {Base64} from \"@openzeppelin/contracts@4.9.6/utils/Base64.sol\";\r\nimport {Strings} from \"@openzeppelin/contracts@4.9.6/utils/Strings.sol\";\r\n\r\ninterface IRegistrationVaultSource {\r\n    function initialized() external view returns (bool);\r\n    function taxToken() external view returns (address);\r\n    function rewardsContract() external view returns (address);\r\n}\r\n\r\n/// @notice Transferable ERC-721 receipt, issued once per original registrant and project.\r\n/// @dev Factory deploys the locked implementation and initializes one clone per vault.\r\ncontract AIDROPRegistrationNFT is ERC721Upgradeable {\r\n    using Strings for uint256;\r\n\r\n    address public vault;\r\n    address public rewardsContract;\r\n    address public taxToken;\r\n    uint256 public totalSupply;\r\n    // Historical issuance record; transfers do not change it or allow another registration mint.\r\n    // Current ownership is tracked by ERC-721 ownerOf and balanceOf.\r\n    mapping(address => uint256) public tokenOf;\r\n\r\n    event RegistrationNFTInitialized(address indexed vault, address indexed rewards, address indexed taxToken);\r\n    event RegistrationReceiptMinted(address indexed user, uint256 indexed tokenId);\r\n\r\n    constructor() { _disableInitializers(); }\r\n\r\n    function initialize(address vault_, address rewards_) external initializer {\r\n        require(block.chainid == 56, \"BSC_MAINNET_ONLY\");\r\n        require(vault_.code.length > 0 && rewards_.code.length > 0, \"BINDING_CODE\");\r\n        IRegistrationVaultSource source = IRegistrationVaultSource(vault_);\r\n        require(source.initialized() && source.rewardsContract() == rewards_, \"VAULT_BINDING\");\r\n        address token = source.taxToken();\r\n        require(token != address(0), \"TOKEN\");\r\n        __ERC721_init(\"drop.ai\", \"drop.ai\");\r\n        vault = vault_;\r\n        rewardsContract = rewards_;\r\n        taxToken = token;\r\n        emit RegistrationNFTInitialized(vault_, rewards_, token);\r\n    }\r\n\r\n    function mintForRegistration(address user) external returns (uint256 tokenId) {\r\n        require(msg.sender == rewardsContract, \"ONLY_REWARDS\");\r\n        require(user != address(0) && tokenOf[user] == 0, \"ALREADY_MINTED_OR_ZERO\");\r\n        tokenId = ++totalSupply;\r\n        tokenOf[user] = tokenId;\r\n        // Registration mint also supports smart accounts without ERC721Receiver.\r\n        // This mint deliberately does not call user-controlled receiver hooks.\r\n        _mint(user, tokenId);\r\n        emit RegistrationReceiptMinted(user, tokenId);\r\n    }\r\n\r\n    function tokenURI(uint256 tokenId) public view override returns (string memory) {\r\n        _requireMinted(tokenId);\r\n        string memory id = tokenId.toString();\r\n        string memory project = Strings.toHexString(taxToken);\r\n        // Pure on-chain vector artwork, traced from the supplied blue water-drop logo.\r\n        // No image URL, external font, embedded raster or off-chain fetch is needed.\r\n        bytes memory svg = abi.encodePacked(\r\n            '<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1600\" height=\"1600\" viewBox=\"0 0 1600 1600\"><rect width=\"1600\" height=\"1600\" fill=\"white\"/><path fill=\"#02a5e6\" fill-rule=\"evenodd\" transform=\"translate(96 12) scale(.88)\" d=\"M798.0,44.5L800.5,45.0L819.5,106.0L850.5,187.0L881.5,256.0L915.5,324.0L995.5,465.0L1117.5,662.0L1159.5,738.0L1189.5,799.0L1216.5,866.0L1235.5,928.0L1249.5,995.0L1255.5,1051.0L1253.5,1139.0L1248.5,1174.0L1237.5,1220.0L1220.5,1267.0L1201.5,1306.0L1173.5,1351.0L1146.5,1386.0L1118.0,1416.5L1079.0,1450.5L1045.0,1474.5L998.0,1500.5L959.0,1517.5L922.0,1529.5L866.0,1541.5L824.0,1545.5L772.0,1545.5L733.0,1541.5L681.0,1530.5L646.0,1519.5L607.0,1503.5L562.0,1479.5L529.0,1457.5L499.0,1433.5L466.5,1402.0L436.5,1367.0L408.5,1326.0L382.5,1277.0L370.5,1248.0L353.5,1191.0L346.5,1153.0L343.5,1119.0L345.5,1029.0L355.5,963.0L371.5,898.0L398.5,825.0L442.5,733.0L474.5,674.0L616.5,443.0L692.5,306.0L727.5,234.0L756.5,167.0L777.5,112.0ZM865.0,300.5L864.5,307.0L904.5,482.0L926.5,561.0L944.5,611.0L967.5,656.0L983.0,674.5L995.0,683.5L1008.0,689.5L1026.0,691.5L1036.0,688.5L1043.5,683.0L1048.5,673.0L1048.5,660.0L1044.5,648.0L1028.5,618.0L944.5,481.0L927.5,447.0L924.5,445.0L889.5,371.0ZM1037.0,753.5L1024.0,757.5L1009.5,770.0L1004.5,780.0L1002.5,796.0L1008.5,814.0L1019.0,825.5L1035.0,832.5L1050.0,832.5L1065.0,826.5L1072.5,820.0L1079.5,809.0L1082.5,790.0L1079.5,778.0L1070.0,764.5L1058.0,756.5ZM818.0,865.5L796.0,867.5L763.0,876.5L748.0,883.5L729.0,896.5L709.5,917.0L700.5,933.0L693.5,955.0L693.5,972.0L699.0,976.5L749.0,976.5L755.5,972.0L764.5,952.0L781.0,936.5L803.0,928.5L835.0,927.5L857.0,933.5L865.0,938.5L876.5,952.0L882.5,973.0L882.5,999.0L776.0,1007.5L748.0,1014.5L718.0,1029.5L693.5,1054.0L682.5,1079.0L679.5,1113.0L685.5,1140.0L696.5,1161.0L715.0,1180.5L734.0,1192.5L763.0,1202.5L796.0,1205.5L822.0,1201.5L851.0,1189.5L881.0,1166.5L883.5,1192.0L889.0,1198.5L944.0,1198.5L948.5,1195.0L950.5,1189.0L950.5,976.0L948.5,956.0L943.5,937.0L927.5,909.0L914.0,895.5L898.0,884.5L884.0,877.5L859.0,869.5ZM1018.0,871.5L1013.0,873.5L1008.5,880.0L1008.5,1190.0L1011.5,1197.0L1017.0,1199.5L1065.0,1199.5L1071.0,1197.5L1076.5,1189.0L1075.5,879.0L1071.0,873.5L1066.0,871.5ZM432.0,942.5L423.5,985.0L417.5,1051.0L417.5,1093.0L421.5,1142.0L431.5,1195.0L443.5,1234.0L465.5,1282.0L485.5,1314.0L514.5,1349.0L562.0,1390.5L600.0,1414.5L652.0,1438.5L686.0,1448.5L715.0,1451.5L751.0,1445.5L784.0,1429.5L801.5,1413.0L808.5,1399.0L808.5,1384.0L800.0,1370.5L786.0,1363.5L741.0,1357.5L700.0,1347.5L672.0,1337.5L641.0,1322.5L594.0,1290.5L563.5,1261.0L545.5,1239.0L514.5,1190.0L481.5,1118.0L454.5,1037.0L439.5,976.0L434.5,945.0ZM876.0,1055.5L882.5,1057.0L881.5,1086.0L877.5,1100.0L869.5,1114.0L846.0,1134.5L822.0,1143.5L795.0,1145.5L768.0,1137.5L753.5,1124.0L748.5,1112.0L748.5,1094.0L755.5,1080.0L768.0,1069.5L786.0,1062.5L804.0,1059.5ZM589.0,1121.5L570.0,1130.5L560.5,1142.0L555.5,1157.0L556.5,1172.0L562.5,1185.0L574.0,1196.5L588.0,1202.5L605.0,1202.5L624.0,1193.5L633.5,1182.0L638.5,1165.0L637.5,1153.0L630.5,1138.0L619.0,1127.5L605.0,1121.5Z\"/><text x=\"800\" y=\"1515\" text-anchor=\"middle\" fill=\"#02a5e6\" font-family=\"monospace\" font-weight=\"bold\" font-size=\"',\r\n            bytes(id).length > 28 ? '24' : '64',\r\n            '\">#', id, '</text></svg>'\r\n        );\r\n        bytes memory json = abi.encodePacked(\r\n            '{\"name\":\"drop.ai #', id,\r\n            '\",\"description\":\"Transferable registration receipt; eligibility and reward history stay with the original registrant.\",',\r\n            '\"image\":\"data:image/svg+xml;base64,', Base64.encode(svg),\r\n            '\",\"attributes\":[{\"trait_type\":\"Project token\",\"value\":\"', project,\r\n            '\"},{\"trait_type\":\"Vault\",\"value\":\"', Strings.toHexString(vault), '\"}]}'\r\n        );\r\n        return string.concat(\"data:application/json;base64,\", Base64.encode(json));\r\n    }\r\n}\r\n"},"@openzeppelin/contracts@4.9.6/utils/Base64.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.6) (utils/Base64.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides a set of functions to operate with Base64 strings.\n *\n * _Available since v4.5._\n */\nlibrary Base64 {\n    /**\n     * @dev Base64 Encoding/Decoding Table\n     */\n    string internal constant _TABLE = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n    /**\n     * @dev Converts a `bytes` to its Bytes64 `string` representation.\n     */\n    function encode(bytes memory data) internal pure returns (string memory) {\n        /**\n         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence\n         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol\n         */\n        if (data.length == 0) return \"\";\n\n        // Loads the table into memory\n        string memory table = _TABLE;\n\n        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter\n        // and split into 4 numbers of 6 bits.\n        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up\n        // - `data.length + 2`  -> Round up\n        // - `/ 3`              -> Number of 3-bytes chunks\n        // - `4 *`              -> 4 characters for each chunk\n        string memory result = new string(4 * ((data.length + 2) / 3));\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Prepare the lookup table (skip the first \"length\" byte)\n            let tablePtr := add(table, 1)\n\n            // Prepare result pointer, jump over length\n            let resultPtr := add(result, 0x20)\n            let dataPtr := data\n            let endPtr := add(data, mload(data))\n\n            // In some cases, the last iteration will read bytes after the end of the data. We cache the value, and\n            // set it to zero to make sure no dirty bytes are read in that section.\n            let afterPtr := add(endPtr, 0x20)\n            let afterCache := mload(afterPtr)\n            mstore(afterPtr, 0x00)\n\n            // Run over the input, 3 bytes at a time\n            for {\n\n            } lt(dataPtr, endPtr) {\n\n            } {\n                // Advance 3 bytes\n                dataPtr := add(dataPtr, 3)\n                let input := mload(dataPtr)\n\n                // To write each character, shift the 3 byte (24 bits) chunk\n                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)\n                // and apply logical AND with 0x3F to bitmask the least significant 6 bits.\n                // Use this as an index into the lookup table, mload an entire word\n                // so the desired character is in the least significant byte, and\n                // mstore8 this least significant byte into the result and continue.\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n\n                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))\n                resultPtr := add(resultPtr, 1) // Advance\n            }\n\n            // Reset the value that was cached\n            mstore(afterPtr, afterCache)\n\n            // When data `bytes` is not exactly 3 bytes long\n            // it is padded with `=` characters at the end\n            switch mod(mload(data), 3)\n            case 1 {\n                mstore8(sub(resultPtr, 1), 0x3d)\n                mstore8(sub(resultPtr, 2), 0x3d)\n            }\n            case 2 {\n                mstore8(sub(resultPtr, 1), 0x3d)\n            }\n        }\n\n        return result;\n    }\n}\n"},"@openzeppelin/contracts@4.9.6/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\nimport \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value))));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts@4.9.6/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"@openzeppelin/contracts@4.9.6/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/AddressUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/StringsUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/MathUpgradeable.sol\";\nimport \"./math/SignedMathUpgradeable.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = MathUpgradeable.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMathUpgradeable.abs(value))));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized != type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/MathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary MathUpgradeable {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/ERC721Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC721Upgradeable.sol\";\nimport \"./IERC721ReceiverUpgradeable.sol\";\nimport \"./extensions/IERC721MetadataUpgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../utils/StringsUpgradeable.sol\";\nimport \"../../utils/introspection/ERC165Upgradeable.sol\";\nimport {Initializable} from \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\ncontract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {\n    using AddressUpgradeable for address;\n    using StringsUpgradeable for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    // Mapping from token ID to owner address\n    mapping(uint256 => address) private _owners;\n\n    // Mapping owner address to token count\n    mapping(address => uint256) private _balances;\n\n    // Mapping from token ID to approved address\n    mapping(uint256 => address) private _tokenApprovals;\n\n    // Mapping from owner to operator approvals\n    mapping(address => mapping(address => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {\n        __ERC721_init_unchained(name_, symbol_);\n    }\n\n    function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {\n        return\n            interfaceId == type(IERC721Upgradeable).interfaceId ||\n            interfaceId == type(IERC721MetadataUpgradeable).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev See {IERC721-balanceOf}.\n     */\n    function balanceOf(address owner) public view virtual override returns (uint256) {\n        require(owner != address(0), \"ERC721: address zero is not a valid owner\");\n        return _balances[owner];\n    }\n\n    /**\n     * @dev See {IERC721-ownerOf}.\n     */\n    function ownerOf(uint256 tokenId) public view virtual override returns (address) {\n        address owner = _ownerOf(tokenId);\n        require(owner != address(0), \"ERC721: invalid token ID\");\n        return owner;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-name}.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-symbol}.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-tokenURI}.\n     */\n    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\n        _requireMinted(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /**\n     * @dev See {IERC721-approve}.\n     */\n    function approve(address to, uint256 tokenId) public virtual override {\n        address owner = ERC721Upgradeable.ownerOf(tokenId);\n        require(to != owner, \"ERC721: approval to current owner\");\n\n        require(\n            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),\n            \"ERC721: approve caller is not token owner or approved for all\"\n        );\n\n        _approve(to, tokenId);\n    }\n\n    /**\n     * @dev See {IERC721-getApproved}.\n     */\n    function getApproved(uint256 tokenId) public view virtual override returns (address) {\n        _requireMinted(tokenId);\n\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev See {IERC721-setApprovalForAll}.\n     */\n    function setApprovalForAll(address operator, bool approved) public virtual override {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /**\n     * @dev See {IERC721-isApprovedForAll}.\n     */\n    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /**\n     * @dev See {IERC721-transferFrom}.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) public virtual override {\n        //solhint-disable-next-line max-line-length\n        require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: caller is not token owner or approved\");\n\n        _transfer(from, to, tokenId);\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {\n        require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: caller is not token owner or approved\");\n        _safeTransfer(from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        require(_checkOnERC721Received(from, to, tokenId, data), \"ERC721: transfer to non ERC721Receiver implementer\");\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `tokenId` exists.\n     *\n     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\n     *\n     * Tokens start existing when they are minted (`_mint`),\n     * and stop existing when they are burned (`_burn`).\n     */\n    function _exists(uint256 tokenId) internal view virtual returns (bool) {\n        return _ownerOf(tokenId) != address(0);\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `tokenId`.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\n        address owner = ERC721Upgradeable.ownerOf(tokenId);\n        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Safely mints `tokenId` and transfers it to `to`.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal virtual {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        require(\n            _checkOnERC721Received(address(0), to, tokenId, data),\n            \"ERC721: transfer to non ERC721Receiver implementer\"\n        );\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal virtual {\n        require(to != address(0), \"ERC721: mint to the zero address\");\n        require(!_exists(tokenId), \"ERC721: token already minted\");\n\n        _beforeTokenTransfer(address(0), to, tokenId, 1);\n\n        // Check that tokenId was not minted by `_beforeTokenTransfer` hook\n        require(!_exists(tokenId), \"ERC721: token already minted\");\n\n        unchecked {\n            // Will not overflow unless all 2**256 token ids are minted to the same owner.\n            // Given that tokens are minted one by one, it is impossible in practice that\n            // this ever happens. Might change if we allow batch minting.\n            // The ERC fails to describe this case.\n            _balances[to] += 1;\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(address(0), to, tokenId);\n\n        _afterTokenTransfer(address(0), to, tokenId, 1);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal virtual {\n        address owner = ERC721Upgradeable.ownerOf(tokenId);\n\n        _beforeTokenTransfer(owner, address(0), tokenId, 1);\n\n        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook\n        owner = ERC721Upgradeable.ownerOf(tokenId);\n\n        // Clear approvals\n        delete _tokenApprovals[tokenId];\n\n        unchecked {\n            // Cannot overflow, as that would require more tokens to be burned/transferred\n            // out than the owner initially received through minting and transferring in.\n            _balances[owner] -= 1;\n        }\n        delete _owners[tokenId];\n\n        emit Transfer(owner, address(0), tokenId);\n\n        _afterTokenTransfer(owner, address(0), tokenId, 1);\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal virtual {\n        require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer from incorrect owner\");\n        require(to != address(0), \"ERC721: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, tokenId, 1);\n\n        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook\n        require(ERC721Upgradeable.ownerOf(tokenId) == from, \"ERC721: transfer from incorrect owner\");\n\n        // Clear approvals from the previous owner\n        delete _tokenApprovals[tokenId];\n\n        unchecked {\n            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:\n            // `from`'s balance is the number of token held, which is at least one before the current\n            // transfer.\n            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require\n            // all 2**256 token ids to be minted, which in practice is impossible.\n            _balances[from] -= 1;\n            _balances[to] += 1;\n        }\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        _afterTokenTransfer(from, to, tokenId, 1);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * Emits an {Approval} event.\n     */\n    function _approve(address to, uint256 tokenId) internal virtual {\n        _tokenApprovals[tokenId] = to;\n        emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId);\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        require(owner != operator, \"ERC721: approve to caller\");\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` has not been minted yet.\n     */\n    function _requireMinted(uint256 tokenId) internal view virtual {\n        require(_exists(tokenId), \"ERC721: invalid token ID\");\n    }\n\n    /**\n     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\n     * The call is not executed if the target address is not a contract.\n     *\n     * @param from address representing the previous owner of the given token ID\n     * @param to target address that will receive the tokens\n     * @param tokenId uint256 ID of the token to be transferred\n     * @param data bytes optional data to send along with the call\n     * @return bool whether the call correctly returned the expected magic value\n     */\n    function _checkOnERC721Received(\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes memory data\n    ) private returns (bool) {\n        if (to.isContract()) {\n            try IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {\n                return retval == IERC721ReceiverUpgradeable.onERC721Received.selector;\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    revert(\"ERC721: transfer to non ERC721Receiver implementer\");\n                } else {\n                    /// @solidity memory-safe-assembly\n                    assembly {\n                        revert(add(32, reason), mload(reason))\n                    }\n                }\n            }\n        } else {\n            return true;\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is\n     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.\n     *\n     * Calling conditions:\n     *\n     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.\n     * - When `from` is zero, the tokens will be minted for `to`.\n     * - When `to` is zero, ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     * - `batchSize` is non-zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is\n     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.\n     *\n     * Calling conditions:\n     *\n     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.\n     * - When `from` is zero, the tokens were minted for `to`.\n     * - When `to` is zero, ``from``'s tokens were burned.\n     * - `from` and `to` are never both zero.\n     * - `batchSize` is non-zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant\n     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such\n     * that `ownerOf(tokenId)` is `a`.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function __unsafe_increaseBalance(address account, uint256 amount) internal {\n        _balances[account] += amount;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[44] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165Upgradeable.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721Upgradeable is IERC165Upgradeable {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the caller.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/SignedMathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMathUpgradeable {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/ERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport {Initializable} from \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n    function __ERC165_init() internal onlyInitializing {\n    }\n\n    function __ERC165_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165Upgradeable).interfaceId;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/IERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721ReceiverUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721ReceiverUpgradeable {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/extensions/IERC721MetadataUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721Upgradeable.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721MetadataUpgradeable is IERC721Upgradeable {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"optimizer":{"runs":200,"enabled":true},"remappings":[]}},"stdJsonOutput":{"sources":{"agent/AIDROPRegistrationNFT.sol":{"id":21},"@openzeppelin/contracts@4.9.6/utils/Base64.sol":{"id":16},"@openzeppelin/contracts@4.9.6/utils/Strings.sol":{"id":17},"@openzeppelin/contracts@4.9.6/utils/math/Math.sol":{"id":19},"@openzeppelin/contracts@4.9.6/utils/math/SignedMath.sol":{"id":20},"@openzeppelin/contracts-upgradeable@4.9.6/utils/AddressUpgradeable.sol":{"id":5},"@openzeppelin/contracts-upgradeable@4.9.6/utils/ContextUpgradeable.sol":{"id":6},"@openzeppelin/contracts-upgradeable@4.9.6/utils/StringsUpgradeable.sol":{"id":7},"@openzeppelin/contracts-upgradeable@4.9.6/proxy/utils/Initializable.sol":{"id":0},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/MathUpgradeable.sol":{"id":10},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/ERC721Upgradeable.sol":{"id":1},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721Upgradeable.sol":{"id":3},"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/SignedMathUpgradeable.sol":{"id":11},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/ERC165Upgradeable.sol":{"id":8},"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/IERC165Upgradeable.sol":{"id":9},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721ReceiverUpgradeable.sol":{"id":2},"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/extensions/IERC721MetadataUpgradeable.sol":{"id":4}},"contracts":{"agent/AIDROPRegistrationNFT.sol":{"AIDROPRegistrationNFT":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"ApprovalForAll","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"operator","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"name":"RegistrationNFTInitialized","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"rewards","type":"address","indexed":true,"internalType":"address"},{"name":"taxToken","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RegistrationReceiptMinted","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"approve","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"vault_","type":"address","internalType":"address"},{"name":"rewards_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isApprovedForAll","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mintForRegistration","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"}],"outputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"rewardsContract","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setApprovalForAll","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"approved","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"taxToken","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"tokenOf","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"vault","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.24+commit.e11b9ed9\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rewards\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"taxToken\",\"type\":\"address\"}],\"name\":\"RegistrationNFTInitialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"RegistrationReceiptMinted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"rewards_\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"}],\"name\":\"mintForRegistration\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rewardsContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"taxToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"tokenOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vault\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Factory deploys the locked implementation and initializes one clone per vault.\",\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when `owner` enables `approved` to manage the `tokenId` token.\"},\"ApprovalForAll(address,address,bool)\":{\"details\":\"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\"},\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `tokenId` token is transferred from `from` to `to`.\"}},\"kind\":\"dev\",\"methods\":{\"approve(address,uint256)\":{\"details\":\"See {IERC721-approve}.\"},\"balanceOf(address)\":{\"details\":\"See {IERC721-balanceOf}.\"},\"getApproved(uint256)\":{\"details\":\"See {IERC721-getApproved}.\"},\"isApprovedForAll(address,address)\":{\"details\":\"See {IERC721-isApprovedForAll}.\"},\"name()\":{\"details\":\"See {IERC721Metadata-name}.\"},\"ownerOf(uint256)\":{\"details\":\"See {IERC721-ownerOf}.\"},\"safeTransferFrom(address,address,uint256)\":{\"details\":\"See {IERC721-safeTransferFrom}.\"},\"safeTransferFrom(address,address,uint256,bytes)\":{\"details\":\"See {IERC721-safeTransferFrom}.\"},\"setApprovalForAll(address,bool)\":{\"details\":\"See {IERC721-setApprovalForAll}.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"symbol()\":{\"details\":\"See {IERC721Metadata-symbol}.\"},\"tokenURI(uint256)\":{\"details\":\"See {IERC721Metadata-tokenURI}.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC721-transferFrom}.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"Transferable ERC-721 receipt, issued once per original registrant and project.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"agent/AIDROPRegistrationNFT.sol\":\"AIDROPRegistrationNFT\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts-upgradeable@4.9.6/proxy/utils/Initializable.sol\":{\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f103ee2e4aecd37aac6ceefe670709cdd7613dee25fa2d4d9feaf7fc0aaa155e\",\"dweb:/ipfs/QmRiNZLoJk5k3HPMYGPGjZFd2ke1ZxjhJZkM45Ec9GH9hv\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/ERC721Upgradeable.sol\":{\"keccak256\":\"0xd6e2dc520133229f192493fc0a53c0cfb0cbcee1e45bf0817c34e416486d9359\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2bda0b8ba2463ef7a8d1189ce54139691f5986aab83a3c502614dd2f29996fe8\",\"dweb:/ipfs/QmapEyXhDZCJL4ho7BQMmZUHtkhyJzABn4iWxyJYae1Kom\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721ReceiverUpgradeable.sol\":{\"keccak256\":\"0xbb2ed8106d94aeae6858e2551a1e7174df73994b77b13ebd120ccaaef80155f5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8bc3c6a456dba727d8dd9fd33420febede490abb49a07469f61d2a3ace66a95a\",\"dweb:/ipfs/QmVAWtEVj7K5AbvgJa9Dz22KiDq9eoptCjnVZqsTMtKXyd\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/IERC721Upgradeable.sol\":{\"keccak256\":\"0xbe63437e37e32162d5d11ea8f11a44378c092b4bcbb05b51a813fe4bf33297d4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://68a514febde6ffd8afe3cb5b40815d10c0a926063237d5d167cbaa90239f75ae\",\"dweb:/ipfs/QmVBvYeR6oGBw7K7vu5FMotr8josejtaGwugM68VTZacww\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/token/ERC721/extensions/IERC721MetadataUpgradeable.sol\":{\"keccak256\":\"0x95a471796eb5f030fdc438660bebec121ad5d063763e64d92376ffb4b5ce8b70\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4ffbd627e6958983d288801acdedbf3491ee0ebf1a430338bce47c96481ce9e3\",\"dweb:/ipfs/QmUM1vpmNgBV34sYf946SthDJNGhwwqjoRggmj4TUUQmdB\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/utils/AddressUpgradeable.sol\":{\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://310136ad60820af4177a11a61d77a3686faf5fca4942b600e08fc940db38396b\",\"dweb:/ipfs/QmbCzMNSTL7Zi7M4UCSqBrkHtp4jjxUnGbkneCZKdR1qeq\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/utils/ContextUpgradeable.sol\":{\"keccak256\":\"0x75097e35253e7fb282ee4d7f27a80eaacfa759923185bf17302a89cbc059c5ef\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8b06267c5f80bad727af3e48b1382333d591dad51376399ef2f6b0ee6d58bf95\",\"dweb:/ipfs/QmdU5La1agcQvghnfMpWZGDPz2TUDTCxUwTLKmuMRXBpAx\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/utils/StringsUpgradeable.sol\":{\"keccak256\":\"0xb96dc79b65b7c37937919dcdb356a969ce0aa2e8338322bf4dc027a3c9c9a7eb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f8613145881436fc0480fff22da4868d611e2b0c0c3da083334eb4362ce1945a\",\"dweb:/ipfs/QmPqpP3YeRbBdTJRe6Gv2eGsUaANf4J6RwTNRW36iYahfV\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/ERC165Upgradeable.sol\":{\"keccak256\":\"0xd90d7723512df65ae417adaf0801042940f0dabd60039ceeaffe34aa5b238da1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1b13befeb3413749292f9fb229de1c7a509a5ce2c8047d9094fc004ca9d3af89\",\"dweb:/ipfs/QmRzJ2hZSwRtMejHUZAYTPRKgZsnfb112Fno9Jf3EiDfwA\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/utils/introspection/IERC165Upgradeable.sol\":{\"keccak256\":\"0xc6cef87559d0aeffdf0a99803de655938a7779ec0a3cd5d4383483ad85565a09\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://92ad7e572cf44e6b4b37631b44b62f9eb9fb1cf14d9ce51c1504d5dc7ccaf758\",\"dweb:/ipfs/QmcnbqX85tsWnUXPmtuPLE4SczME2sJaTfmqEFkuAJvWhy\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/MathUpgradeable.sol\":{\"keccak256\":\"0x2bc0007987c229ae7624eb29be6a9b84f6a6a5872f76248b15208b131ea41c4e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2b2835c737d073ef8b82a4cc246495a9740f43e7ff2cf130906b2449ff9bfb91\",\"dweb:/ipfs/QmSCWfNoSvvTN57ic7o1RW6NqSxxGAqbBTnLKc7QHe27qB\"]},\"@openzeppelin/contracts-upgradeable@4.9.6/utils/math/SignedMathUpgradeable.sol\":{\"keccak256\":\"0x88f6b7bba3ee33eeb741f9a0f5bc98b6e6e352d0fe4905377bb328590f84095a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://88ace2d60f265752f18903d839910be4e4e104340b2957678585b812447825d4\",\"dweb:/ipfs/QmXFkNxMc3AAGzhs2wUEZyErWQjsvoTGyYjuU5oZkFki5Z\"]},\"@openzeppelin/contracts@4.9.6/utils/Base64.sol\":{\"keccak256\":\"0x822fe67e9e671773d29c8182e7287b42edf5f575eab1eb98558d5ccbdff61c96\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7ce73cb57d5a2e705a0a65cac2ed73ab2fa91932e8af22b7ec1a6a3d88f28669\",\"dweb:/ipfs/QmcbjWFekUTsNeoFwGgUT4xtXoVzsA38ca9pkC4jxvxy7L\"]},\"@openzeppelin/contracts@4.9.6/utils/Strings.sol\":{\"keccak256\":\"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b81d9ff6559ea5c47fc573e17ece6d9ba5d6839e213e6ebc3b4c5c8fe4199d7f\",\"dweb:/ipfs/QmPCW1bFisUzJkyjroY3yipwfism9RRCigCcK1hbXtVM8n\"]},\"@openzeppelin/contracts@4.9.6/utils/math/Math.sol\":{\"keccak256\":\"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c\",\"dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS\"]},\"@openzeppelin/contracts@4.9.6/utils/math/SignedMath.sol\":{\"keccak256\":\"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c50fcc459e49a9858b6d8ad5f911295cb7c9ab57567845a250bf0153f84a95c7\",\"dweb:/ipfs/QmcEW85JRzvDkQggxiBBLVAasXWdkhEysqypj9EaB6H2g6\"]},\"agent/AIDROPRegistrationNFT.sol\":{\"keccak256\":\"0xd854a58ffa2521a0d5445f8a367a0c8f9f337b49d8da9a99e37480b211748859\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://aedd23d4fefcd6b441b55b97b8b63b34cc04a1385000611010132ec60fbffc8d\",\"dweb:/ipfs/QmUkECeictRRPgSpxo7nyHDN3zXn1TQv9sktH8va44pZhz\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Transferable ERC-721 receipt, issued once per original registrant and project.","methods":{},"version":1},"devdoc":{"kind":"dev","events":{"Initialized(uint8)":{"details":"Triggered when the contract has been initialized or reinitialized."},"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."}},"details":"Factory deploys the locked implementation and initializes one clone per vault.","methods":{"name()":{"details":"See {IERC721Metadata-name}."},"symbol()":{"details":"See {IERC721Metadata-symbol}."},"ownerOf(uint256)":{"details":"See {IERC721-ownerOf}."},"tokenURI(uint256)":{"details":"See {IERC721Metadata-tokenURI}."},"balanceOf(address)":{"details":"See {IERC721-balanceOf}."},"getApproved(uint256)":{"details":"See {IERC721-getApproved}."},"approve(address,uint256)":{"details":"See {IERC721-approve}."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"setApprovalForAll(address,bool)":{"details":"See {IERC721-setApprovalForAll}."},"isApprovedForAll(address,address)":{"details":"See {IERC721-isApprovedForAll}."},"transferFrom(address,address,uint256)":{"details":"See {IERC721-transferFrom}."},"safeTransferFrom(address,address,uint256)":{"details":"See {IERC721-safeTransferFrom}."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"See {IERC721-safeTransferFrom}."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint8":{"label":"uint8","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_array(t_uint256)44_storage":{"base":"t_uint256","label":"uint256[44]","encoding":"inplace","numberOfBytes":"1408"},"t_array(t_uint256)50_storage":{"base":"t_uint256","label":"uint256[50]","encoding":"inplace","numberOfBytes":"1600"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_address)":{"key":"t_uint256","label":"mapping(uint256 => address)","value":"t_address","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_bool))":{"key":"t_address","label":"mapping(address => mapping(address => bool))","value":"t_mapping(t_address,t_bool)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint8","astId":6,"label":"_initialized","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"0","type":"t_bool","astId":9,"label":"_initializing","offset":1,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"1","type":"t_array(t_uint256)50_storage","astId":1662,"label":"__gap","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"51","type":"t_array(t_uint256)50_storage","astId":1936,"label":"__gap","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"101","type":"t_string_storage","astId":198,"label":"_name","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"102","type":"t_string_storage","astId":200,"label":"_symbol","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"103","type":"t_mapping(t_uint256,t_address)","astId":204,"label":"_owners","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"104","type":"t_mapping(t_address,t_uint256)","astId":208,"label":"_balances","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"105","type":"t_mapping(t_uint256,t_address)","astId":212,"label":"_tokenApprovals","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"106","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":218,"label":"_operatorApprovals","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"107","type":"t_array(t_uint256)44_storage","astId":1120,"label":"__gap","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"151","type":"t_address","astId":5031,"label":"vault","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"152","type":"t_address","astId":5033,"label":"rewardsContract","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"153","type":"t_address","astId":5035,"label":"taxToken","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"154","type":"t_uint256","astId":5037,"label":"totalSupply","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"},{"slot":"155","type":"t_mapping(t_address,t_uint256)","astId":5041,"label":"tokenOf","offset":0,"contract":"agent/AIDROPRegistrationNFT.sol:AIDROPRegistrationNFT"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"727:6240:21:-:0;;;;;;;6007:13:0;727:6240:21;;;;;;;;;;;;;;6078:31:0;6074:139;;-1:-1:-1;727:6240:21;;;;;;;;;6074:139:0;727:6240:21;;;;;;6007:13:0;727:6240:21;6174:28:0;727:6240:21;;;;;;6174:28:0;6074:139;;;727:6240:21;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"727:6240:21:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;820:20;727:6240;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;5001:18:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;13872:53:1;;-1:-1:-1;;;;;727:6240:21;7701:31:1;;13872:53;:::i;:::-;727:6240:21;;2829:18;10276:8:19;2829:18:21;10267:17:19;;;;10263:103;;727:6240:21;10392:8:19;;;;10383:17;;;;10379:103;;727:6240:21;10508:8:19;;;10499:17;;;;10495:103;;727:6240:21;10624:7:19;;10615:16;;;;10611:100;;727:6240:21;10737:7:19;;10728:16;;;;10724:100;;727:6240:21;10841:16:19;10850:7;10841:16;;;10837:100;;727:6240:21;10963:7:19;;10954:16;;;10950:66;;727:6240:21;;;;731:76:17;627:18;727:6240:21;;;627:18:17;:::i;:::-;659:11;731:76;;;820:280;727:6240:21;;;820:280:17;727:6240:21;;;;;6429:442;;6936:19;727:6240;;;;;;;;2882:29;727:6240;2902:8;727:6240;;2882:29;:::i;:::-;727:6240;6330:2;727:6240;;6311:21;:35;;;;6826:26;6674:18;727:6240;;;;;:::i;:::-;;;;-1:-1:-1;;;727:6240:21;;;;6311:35;3117:3281;;727:6240;;3117:3281;;727:6240;3117:3281;;;727:6240;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;:::i;:::-;;;;;;3117:3281;;;;;;;;;:::i;:::-;6674:18;:::i;:::-;727:6240;6846:5;727:6240;;6826:26;:::i;:::-;727:6240;;;;;;;;;6429:442;;;727:6240;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;6429:442;;;;;;;;;:::i;6936:19::-;727:6240;;6429:442;727:6240;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;;6311:35;6826:26;6674:18;727:6240;;;;;:::i;:::-;;;;-1:-1:-1;;;727:6240:21;;;;6311:35;;820:280:17;-1:-1:-1;;727:6240:21;;;;-1:-1:-1;;;925:93:17;;;;727:6240:21;925:93:17;727:6240:21;1068:10:17;;;1064:21;;820:280;;;;;1064:21;1080:5;;10950:66:19;727:6240:21;;;10950:66:19;;;10837:100;727:6240:21;;10850:7:19;10921:1;727:6240:21;;;;10837:100:19;;;10724;727:6240:21;;;;;;;10724:100:19;;;;10611;10695:1;727:6240:21;;;;;;10611:100:19;;;;10495:103;10581:2;727:6240:21;;;;;;10495:103:19;;;;10379;727:6240:21;;;;;;;10379:103:19;;;;10263;727:6240:21;;-1:-1:-1;727:6240:21;;-1:-1:-1;10263:103:19;;;;727:6240:21;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;727:6240:21;;965:10:6;13549:17:1;;727:6240:21;;965:10:6;727:6240:21;;13606:18:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13667:41:1;727:6240:21;965:10:6;13667:41:1;;727:6240:21;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;3203:7:1;727:6240:21;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;3203:7:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;-1:-1:-1;727:6240:21;;-1:-1:-1;727:6240:21;;;;;;;-1:-1:-1;;727:6240:21;;;;-1:-1:-1;;;;;727:6240:21;;:::i;:::-;;2510:19:1;;727:6240:21;;;;2592:9:1;727:6240:21;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2232:15;727:6240;-1:-1:-1;;;;;727:6240:21;;;;2218:10;:29;727:6240;;;2283:18;;;;:40;;;727:6240;;;;2371:13;727:6240;-1:-1:-1;;727:6240:21;;;;;;;;2371:13;727:6240;;;;2395:7;727:6240;;;;;;;;;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;9571:58:1;;-1:-1:-1;;;;;727:6240:21;7701:31:1;;9580:16;9579:17;9571:58;:::i;:::-;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;9775:58:1;;-1:-1:-1;;;;;727:6240:21;7701:31:1;;9784:16;7613:126;9775:58;727:6240:21;;;10175:9:1;727:6240:21;;;;;;;;;;;;;;10214:7:1;727:6240:21;;;;;;;;;;;;;;;;;;10251:33:1;;;727:6240:21;10251:33:1;;;;2629:40:21;727:6240;2629:40;;727:6240;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;2283:40;727:6240;;;;2305:7;727:6240;;;;;;2305:18;2283:40;;727:6240;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;3301:14:0;3347:34;;;;;;727:6240:21;3346:108:0;;;;727:6240:21;;;;-1:-1:-1;;727:6240:21;;3551:1:0;727:6240:21;;;;3562:65:0;;727:6240:21;1511:13;1528:2;1511:13;:19;727:6240;;1570:18;;:22;;:50;;;727:6240;;;;;;-1:-1:-1;;;1733:20:21;;727:6240;;;;-1:-1:-1;;;;;727:6240:21;;1733:20;;;;;;;727:6240;1733:20;;;727:6240;1733:60;;;;727:6240;;;;;;-1:-1:-1;;;1838:17:21;;727:6240;;;;;-1:-1:-1;;;;;727:6240:21;;1838:17;;;;;;;727:6240;1838:17;;;727:6240;-1:-1:-1;;;;;;727:6240:21;;1874:19;727:6240;;;;:::i;:::-;;;:::i;:::-;;5366:69:0;727:6240:21;;;;;;5366:69:0;;;:::i;:::-;;:::i;:::-;727:6240:21;;;;;;;;;;;1894:13:1;727:6240:21;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;1894:13:1;727:6240:21;;;;;;;;;;;;;1917:17:1;727:6240:21;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;1917:17:1;727:6240:21;;1960:14;727:6240;;-1:-1:-1;;;;;727:6240:21;;;-1:-1:-1;;;;;;727:6240:21;;;;;;;;1985:26;727:6240;;;;;;;;;;;;2022:16;727:6240;;;;;;;;;;;;;;;;;2054:51;-1:-1:-1;;2054:51:21;3647:99:0;;727:6240:21;3647:99:0;727:6240:21;3721:14:0;727:6240:21;;;;;;;;3551:1:0;727:6240:21;;3721:14:0;727:6240:21;;;;;-1:-1:-1;727:6240:21;;;;;1917:17:1;727:6240:21;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;;;;1917:17:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;;;;;;;;;1917:17:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3551:1:0;727:6240:21;;;;;;-1:-1:-1;727:6240:21;;;;;;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;;;;;;1894:13:1;727:6240:21;;-1:-1:-1;;;;;;;;;;;727:6240:21;;;;-1:-1:-1;;727:6240:21;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;;;;;;;1894:13:1;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3551:1:0;727:6240:21;;;;;;;;;;;;;;1894:13:1;727:6240:21;;;;;;;-1:-1:-1;;;;;;;;;;;727:6240:21;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;3551:1:0;727:6240:21;;;;-1:-1:-1;;;;;;;;;;;727:6240:21;-1:-1:-1;727:6240:21;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;1838:17;;;;;727:6240;1838:17;727:6240;1838:17;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;727:6240;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;1733:60;-1:-1:-1;727:6240:21;;-1:-1:-1;;;1757:24:21;;727:6240;;;;-1:-1:-1;;;;;727:6240:21;;1757:24;;;;;;;727:6240;1757:24;;;1733:60;-1:-1:-1;;;;;;727:6240:21;;;;;1757:36;1733:60;;1757:24;;;;727:6240;1757:24;727:6240;1757:24;;;;;;;:::i;:::-;;;;1733:20;;;727:6240;1733:20;;727:6240;1733:20;;;;;;727:6240;1733:20;;;:::i;:::-;;;727:6240;;;;;;;;;;;;1733:20;;;;;;-1:-1:-1;1733:20:21;;727:6240;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;1570:50;1596:20;;;:24;;1570:50;;727:6240;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;3562:65:0;-1:-1:-1;;727:6240:21;;;;;3562:65:0;;;727:6240:21;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;3346:108:0;3426:4;;1713:19:5;:23;3387:66:0;;3346:108;3387:66;727:6240:21;3452:1:0;727:6240:21;;;3436:17:0;3346:108;;3347:34;727:6240:21;3380:1:0;727:6240:21;;;3365:16:0;3347:34;;727:6240:21;;;;;;-1:-1:-1;;727:6240:21;;;;-1:-1:-1;;;;;727:6240:21;;:::i;:::-;;;;1117:42;727:6240;;;;;;;;;;;;;;;;;5570:39:1;727:6240:21;;;:::i;:::-;;;;;;;;:::i;:::-;;;;5570:39:1;:::i;727:6240:21:-;;;;5386:7:1;727:6240:21;;;:::i;:::-;965:10:6;5256:99:1;5264:41;965:10:6;;5264:41:1;:::i;:::-;5256:99;:::i;:::-;5386:7;:::i;727:6240:21:-;;;;;;-1:-1:-1;;727:6240:21;;;;847:30;727:6240;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;884:23;727:6240;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;914:26;727:6240;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;727:6240:21;;4046:34:1;727:6240:21;4046:34:1;:::i;:::-;727:6240:21;;;4098:11:1;;;;727:6240:21;;965:10:6;;4179:21:1;:62;;;;;727:6240:21;;;;;;;;;13194:15:1;727:6240:21;;;;;;;-1:-1:-1;;;;;;727:6240:21;;;;;13247:34:1;727:6240:21;13247:34:1;:::i;:::-;727:6240:21;13238:57:1;727:6240:21;13238:57:1;;727:6240:21;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;4179:62:1;727:6240:21;;;;5001:18:1;727:6240:21;;;;;965:10:6;727:6240:21;;;;;;;;;;4179:62:1;;;727:6240:21;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;727:6240:21;;;;;;3039:5:1;727:6240:21;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;3039:5:1;727:6240:21;;-1:-1:-1;;;;;;;;;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;727:6240:21;;;;;;;;;;;;;;;;-1:-1:-1;;727:6240:21;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2167:51:1;;;:126;;;;727:6240:21;2167:178:1;;;;727:6240:21;;;;;;;2167:178:1;-1:-1:-1;;;1189:51:8;;-1:-1:-1;2167:178:1;;;:126;-1:-1:-1;;;2234:59:1;;;-1:-1:-1;2167:126:1;;727:6240:21;;;;;;;;-1:-1:-1;;727:6240:21;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;727:6240:21;;;;:::o;:::-;;;;-1:-1:-1;;;;;727:6240:21;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;727:6240:21;;;;;;:::o;:::-;;;;;;;;;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;727:6240:21;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;4428:167:1;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;13872:53:1;;-1:-1:-1;;;;;727:6240:21;7701:31:1;;13872:53;:::i;:::-;-1:-1:-1;727:6240:21;;;4564:15:1;727:6240:21;;;;;;-1:-1:-1;;;;;727:6240:21;;4428:167:1:o;727:6240:21:-;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;727:6240:21;;;;;;;:::o;:::-;;;;;;;:::i;:::-;;;;-1:-1:-1;;;727:6240:21;;;;:::o;:::-;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;2672:219:1;-1:-1:-1;727:6240:21;;;7287:7:1;727:6240:21;;;;;;-1:-1:-1;;;;;727:6240:21;2806:56:1;2814:19;;;2806:56;:::i;:::-;2672:219;:::o;5682:276::-;;6977:47;5682:276;;;5804:99;5812:41;965:10:6;;5812:41:1;:::i;5804:99::-;6951:7;;;;;:::i;:::-;6977:47;:::i;:::-;727:6240:21;;;5682:276:1:o;727:6240:21:-;;;-1:-1:-1;;;727:6240:21;;;;;;;;:::i;:::-;;;;7897:272:1;;-1:-1:-1;;;;;727:6240:21;;8022:34:1;7897:272;8022:34;:::i;:::-;727:6240:21;;;8074:16:1;;;;:52;;;;;7897:272;8074:87;;;;;7897:272;8066:96;;;7897:272;:::o;8074:87::-;8130:20;;;;;;:::i;:::-;727:6240:21;8130:31:1;8074:87;;;;;:52;727:6240:21;;;-1:-1:-1;727:6240:21;5001:18:1;727:6240:21;;;-1:-1:-1;727:6240:21;;-1:-1:-1;727:6240:21;;;;;-1:-1:-1;727:6240:21;;;8074:52:1;;;;727:6240:21;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;11783:1225:1;;11872:92;11783:1225;11880:34;;;:::i;:::-;-1:-1:-1;;;;;727:6240:21;;;;;;;;;;;11880:42:1;;11872:92;:::i;:::-;727:6240:21;11982:16:1;;;727:6240:21;;12192:34:1;12184:92;12192:34;;;;:::i;:::-;727:6240:21;12192:42:1;12184:92;:::i;:::-;727:6240:21;11996:1:1;727:6240:21;12345:15:1;727:6240:21;;;11996:1:1;727:6240:21;;;;;;;;;;;;11996:1:1;727:6240:21;12813:9:1;727:6240:21;;;11996:1:1;727:6240:21;;;;;;;;;11996:1:1;727:6240:21;;11996:1:1;727:6240:21;12832:1:1;727:6240:21;;;;;;11996:1:1;727:6240:21;12885:7:1;727:6240:21;;;;11996:1:1;727:6240:21;;;;;;;;12922:27:1;11996:1;12922:27;;11783:1225::o;727:6240:21:-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;727:6240:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;727:6240:21;;;;;;:::o;:::-;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;:::o;2407:149:17:-;727:6240:21;;;-1:-1:-1;;;;;727:6240:21;;;;:::i;:::-;345:66:16;727:6240:21;;;;;;;;;;;;;;;1975:15:17;;;727:6240:21;;345:66:16;;727:6240:21;345:66:16;727:6240:21;;;;;2000:15:17;727:6240:21;;;2000:15:17;345:66:16;2025:128:17;2058:5;;;;;;2170:10;;;278:18;;2407:149;:::o;278:18::-;;727:6240:21;;;;;278:18:17;;727:6240:21;2141:1:17;278:18;;;727:6240:21;278:18:17;;;727:6240:21;278:18:17;727:6240:21;;;278:18:17;;2065:3;2105:11;;;2113:3;2105:11;;2096:21;;;;;;727:6240:21;;;;;;;-1:-1:-1;;;2096:21:17;;727:6240:21;;;;;2084:33:17;2141:1;727:6240:21;2065:3:17;727:6240:21;;;;-1:-1:-1;;727:6240:21;;2030:26:17;;;727:6240:21;;;;-1:-1:-1;727:6240:21;;2141:1:17;727:6240:21;;-1:-1:-1;727:6240:21;505:3382:16;;727:6240:21;;795:16:16;791:31;;727:6240:21;;;;;;:::i;:::-;;;;;;;;;;;;;;;;1357:1:16;;345:66;1357:1;345:66;;;;;;;1362:1;;727:6240:21;;;-1:-1:-1;;;;;345:66:16;;;;;;1326:39;345:66;1357:1;345:66;;;;1326:39;:::i;:::-;1419:2438;727:6240:21;1419:2438:16;;;;;;;;;;727:6240:21;1419:2438:16;;;;;;810:1;1419:2438;;;;;;;;;;;;1362:1;1419:2438;;;;;;;;1362:1;1419:2438;1362:1;;;1419:2438;;;;3867:13;505:3382;:::o;1419:2438::-;;;-1:-1:-1;;1419:2438:16;;505:3382;:::o;1419:2438::-;-1:-1:-1;1419:2438:16;;;-1:-1:-1;;1419:2438:16;;;-1:-1:-1;;1419:2438:16;;505:3382;:::o;1419:2438::-;;1337:1;1419:2438;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;791:31;727:6240:21;;;;;;;:::i;:::-;810:1:16;727:6240:21;;813:9:16;:::o;14484:853:1:-;;;;;;1713:19:5;;:23;:19;;727:6240:21;-1:-1:-1;727:6240:21;;;;;;;;;;;;;;;;;;;;;14688:82:1;;;;965:10:6;14688:82:1;;;727:6240:21;;;;;;;;;;;;;;;14688:82:1;;727:6240:21;;;;;;;;:::i;:::-;14688:82:1;727:6240:21;;14688:82:1;;-1:-1:-1;;14688:82:1;;;14649:682;-1:-1:-1;14684:595:1;;14898:381;727:6240:21;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;727:6240:21;;;;;;;;14948:18:1;;;727:6240:21;;-1:-1:-1;;;14990:60:1;;727:6240:21;14990:60:1;14688:82;14990:60;;;:::i;14944:321::-;15152:95;;727:6240:21;;;;14684:595:1;-1:-1:-1;;;;;;727:6240:21;14820:62:1;;-1:-1:-1;14813:69:1:o;14688:82::-;;;;;;;;;;;;;;;;;:::i;:::-;;;727:6240:21;;;;;-1:-1:-1;;;;;;727:6240:21;;;;;;14688:82:1;;;;;;;;;14649:682;-1:-1:-1;15316:4:1;;-1:-1:-1;;;15309:11:1:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"getApproved(uint256)","signatureHash4":"0x081812fc","signatureHash32":"0x081812fc55e34fdc7cf5d8b5cf4e3621fa6423fde952ec6ab24afdc0d85c0b2e"},{"signature":"initialize(address,address)","signatureHash4":"0x485cc955","signatureHash32":"0x485cc955cd05f29985ce37d87ac35dcf2fdbc60b9106f66a532e31a2f1d5743b"},{"signature":"isApprovedForAll(address,address)","signatureHash4":"0xe985e9c5","signatureHash32":"0xe985e9c5c6636c6879256001057b28ccac7718ef0ac56553ff9b926452cab8a3"},{"signature":"mintForRegistration(address)","signatureHash4":"0x6c67be49","signatureHash32":"0x6c67be49ff22dadc6aa1f94253fb22702ad955f49bd156802aa6799df8d7ddd4"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"ownerOf(uint256)","signatureHash4":"0x6352211e","signatureHash32":"0x6352211e6566aa027e75ac9dbf2423197fbd9b82b9d981a3ab367d355866aa1c"},{"signature":"rewardsContract()","signatureHash4":"0x220cce97","signatureHash32":"0x220cce97be2f0ad866141dfb7c45c8314b637b283bcde96ec9f6df60a5e52908"},{"signature":"safeTransferFrom(address,address,uint256)","signatureHash4":"0x42842e0e","signatureHash32":"0x42842e0eb38857a7775b4e7364b2775df7325074d088e7fb39590cd6281184ed"},{"signature":"safeTransferFrom(address,address,uint256,bytes)","signatureHash4":"0xb88d4fde","signatureHash32":"0xb88d4fde60196325a28bb7f99a2582e0b46de55b18761e960c14ad7a32099465"},{"signature":"setApprovalForAll(address,bool)","signatureHash4":"0xa22cb465","signatureHash32":"0xa22cb4651ab9570f89bb516380c40ce76762284fb1f21337ceaf6adab99e7d4a"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"taxToken()","signatureHash4":"0x1fc928ae","signatureHash32":"0x1fc928ae772c7110fa54a857bcb2656113c6feacd4b28c932741b8c55ab29a27"},{"signature":"tokenOf(address)","signatureHash4":"0x42ec38e2","signatureHash32":"0x42ec38e215db5d0084f3bafbc4f11aacbb703c8dd77950cdcfdede27922bdbc6"},{"signature":"tokenURI(uint256)","signatureHash4":"0xc87b56dd","signatureHash32":"0xc87b56dda752230262935940d907f047a9f86bb5ee6aa33511fc86db33fea6cc"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"vault()","signatureHash4":"0xfbfa77cf","signatureHash32":"0xfbfa77cfa16f85c900b53d1065f840fd1fc574b2cd12cde1a86984206875ef23"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"ApprovalForAll(address,address,bool)","signatureHash4":"0x17307eab","signatureHash32":"0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31"},{"signature":"Initialized(uint8)","signatureHash4":"0x7f26b83f","signatureHash32":"0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498"},{"signature":"RegistrationNFTInitialized(address,address,address)","signatureHash4":"0xd7ee11e9","signatureHash32":"0xd7ee11e99cabda2fff26fe0f6f51344d59c5c6b3860082af6d33ec24d0b8e6ee"},{"signature":"RegistrationReceiptMinted(address,uint256)","signatureHash4":"0xfd1995ad","signatureHash32":"0xfd1995ad60fcfdd104c7a1a5a012e20956cdefe209014cc852dd3bdeb7b8b58b"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0x8062e3D4F1D906A309b331E727bE1C368631C156"}