{"matchId":"39624541","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-07-04T07:17:07Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"6043:17293:6:-:0;;;1279:4:2;1220:66;;8692:278:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;8760:21:6;;8752:52;;;;-1:-1:-1;;;8752:52:6;;;;;;;;;;;;-1:-1:-1;;;;;8822:25:6;;8814:56;;;;-1:-1:-1;;;8814:56:6;;;;;;;;;;;;-1:-1:-1;;;;;8880:16:6;;;;;8906:25;;;;8941:22;:20;:22::i;:::-;8692:278;;6043:17293;;7121:737:3;-1:-1:-1;;7297:8:3;;7328:1;7321:9;;7318:134;;;7362:10;7356:4;7349:24;7433:4;7427;7420:18;7318:134;-1:-1:-1;;;;;7537:9:3;7533:1;7530;7526:9;7523:24;7513:329;;7665:9;7662:1;7658:17;7655:1;7648:28;7755:9;7749:4;7742:23;7799:28;7793:4;7787;7782:46;7513:329;;;7274:578;7121:737::o;14:177:10:-;93:13;;-1:-1:-1;;;;;135:31:10;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;:::-;6043:17293:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220b5494a84e0a41141dcde381487bab18b032293b25802163e11e78e1de1d8785364736f6c63430008220033","offset":9648}},"transformations":[{"type":"insert","offset":9701,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x0000000000000000000000007a18edfe055488a3128f01f563e5b479d92ffc3a00000000000000000000000058ca52ebe0dadfdf531cde7062e76746de4db1eb"}},"runtimeBytecode":{"onchainBytecode":"0x6080604052600436106102b6575f3560e01c80635325ad3d116101705780638da5cb5b116100d1578063d784d42611610087578063f04e283e11610062578063f04e283e146107a0578063f2fde38b146107b3578063fee81cf4146107c6575f5ffd5b8063d784d4261461074d578063eef09bad1461076c578063ef8493cd14610781575f5ffd5b8063989fff14116100b7578063989fff14146106dc578063ac8a584a1461070f578063af267f8f1461072e575f5ffd5b80638da5cb5b1461068a5780639870d7fe146106bd575f5ffd5b8063715018a6116101265780638a8c3cb01161010c5780638a8c3cb01461062d5780638becfd881461064c5780638c1c34c91461066b575f5ffd5b8063715018a614610606578063778356411461060e575f5ffd5b80635c60da1b116101565780635c60da1b1461059d5780636d70f7ae146105c857806370480275146105e7575f5ffd5b80635325ad3d1461056757806354d1f13d14610595575f5ffd5b8063256929621161021a57806349493a4d116101d05780634f1ef286116101b65780634f1ef2861461050b578063514e62fc1461051e57806352d1902d14610553575f5ffd5b806349493a4d146104c55780634a4ee7b1146104f8575f5ffd5b80632a083ca3116102005780632a083ca3146104515780632de948071461047557806341462ce4146104a6575f5ffd5b8063256929621461042a57806325b5af6c14610432575f5ffd5b80631c10893f1161026f5780631d9ce1d1116102555780631d9ce1d1146103cd5780631f264778146103ec57806324d7806c1461040b575f5ffd5b80631c10893f146103755780631cd64df414610388575f5ffd5b80631785f53c1161029f5780631785f53c146103245780631794bb3c14610343578063183a4f6e14610362575f5ffd5b806304f1d3c7146102ba5780630a3c440514610303575b5f5ffd5b3480156102c5575f5ffd5b506102d96102d4366004611ec3565b6107f7565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b34801561030e575f5ffd5b5061032261031d366004611f22565b610807565b005b34801561032f575f5ffd5b5061032261033e366004611faf565b610987565b34801561034e575f5ffd5b5061032261035d366004611fca565b61099d565b610322610370366004611ec3565b610ae1565b610322610383366004612008565b610aeb565b348015610393575f5ffd5b506103bd6103a2366004612008565b638b78c6d8600c9081525f9290925260209091205481161490565b60405190151581526020016102fa565b3480156103d8575f5ffd5b506103226103e7366004611faf565b610b01565b3480156103f7575f5ffd5b506102d9610406366004612008565b610b57565b348015610416575f5ffd5b506103bd610425366004611faf565b610b68565b610322610b86565b34801561043d575f5ffd5b5061032261044c366004611faf565b610bd3565b34801561045c575f5ffd5b5061046762093a8081565b6040519081526020016102fa565b348015610480575f5ffd5b5061046761048f366004611faf565b638b78c6d8600c9081525f91909152602090205490565b3480156104b1575f5ffd5b506103226104c0366004611faf565b610c4e565b3480156104d0575f5ffd5b506102d97f0000000000000000000000007a18edfe055488a3128f01f563e5b479d92ffc3a81565b610322610506366004612008565b610ca4565b610322610519366004612032565b610cb6565b348015610529575f5ffd5b506103bd610538366004612008565b638b78c6d8600c9081525f9290925260209091205416151590565b34801561055e575f5ffd5b50610467610d69565b348015610572575f5ffd5b506103bd610581366004611faf565b60026020525f908152604090205460ff1681565b610322610d97565b3480156105a8575f5ffd5b505f546102d99073ffffffffffffffffffffffffffffffffffffffff1681565b3480156105d3575f5ffd5b506103bd6105e2366004611faf565b610dd0565b3480156105f2575f5ffd5b50610322610601366004611faf565b610dee565b610322610e01565b348015610619575f5ffd5b50610322610628366004611f22565b610e14565b348015610638575f5ffd5b50610322610647366004611faf565b6111f8565b348015610657575f5ffd5b506102d9610666366004611ec3565b6112c3565b348015610676575f5ffd5b506103bd610685366004611faf565b61131e565b348015610695575f5ffd5b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927546102d9565b3480156106c8575f5ffd5b506103226106d7366004611faf565b61133c565b3480156106e7575f5ffd5b506102d97f00000000000000000000000058ca52ebe0dadfdf531cde7062e76746de4db1eb81565b34801561071a575f5ffd5b50610322610729366004611faf565b611392565b348015610739575f5ffd5b50610322610748366004611ec3565b6113e8565b348015610758575f5ffd5b50610322610767366004611faf565b61143c565b348015610777575f5ffd5b5061046760015481565b34801561078c575f5ffd5b5061032261079b366004611f22565b61144d565b6103226107ae366004611faf565b611755565b6103226107c1366004611faf565b61178f565b3480156107d1575f5ffd5b506104676107e0366004611faf565b63389a75e1600c9081525f91909152602090205490565b5f610801826117b5565b92915050565b638b78c6d8600c908152335f526020902054600216610852576040517f27e1f1e500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b82811461088b576040517fa24a13a600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5b83811015610980578484828181106108a7576108a76120b2565b90506020028101906108b991906120df565b6108c7906020810190611faf565b73ffffffffffffffffffffffffffffffffffffffff1663e8c8bf648686848181106108f4576108f46120b2565b905060200281019061090691906120df565b858585818110610918576109186120b2565b905060200281019061092a919061211b565b6040518463ffffffff1660e01b815260040161094893929190612300565b5f604051808303815f87803b15801561095f575f5ffd5b505af1158015610971573d5f5f3e3d5ffd5b5050505080600101905061088d565b5050505050565b61098f611810565b61099a816001611845565b50565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffbf60113280546003825580156109ee5760018160011c14303b106109e55763f92ee8a95f526004601cfd5b818160ff1b1b91505b5073ffffffffffffffffffffffffffffffffffffffff8416610a3c576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8316610a89576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610a9284611850565b610a9d8360016118b3565b610aa6826118f4565b8015610adb576002815560016020527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2602080a15b50505050565b61099a3382611845565b610af3611810565b610afd8282611978565b5050565b638b78c6d8600c908152335f526020902054600116610b4c576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61099a816004611845565b5f610b61826117b5565b9392505050565b638b78c6d8600c9081525f8281526020909120546001161515610801565b5f6202a30067ffffffffffffffff164201905063389a75e1600c52335f52806020600c2055337fdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d5f5fa250565b610bdb611810565b73ffffffffffffffffffffffffffffffffffffffff81165f8181526002602052604080822080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00169055517f595b3b62b3cba6f524d35709e19e9500b32b8431c58140fa081442ca1b6c07f09190a250565b638b78c6d8600c908152335f526020902054600116610c99576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61099a816004611978565b610cac611810565b610afd8282611845565b610cbe611984565b610cc7836119b3565b8260601b60601c92503d5f526352d1902d6001527f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80602060016004601d885afa5114610d1c576355299b496001526004601dfd5b837fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f38a28390558015610d6457604051818382375f388383875af4610adb573d5f823e3d81fd5b505050565b5f610d726119bb565b507f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc90565b63389a75e1600c52335f525f6020600c2055337ffa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c925f5fa2565b638b78c6d8600c9081525f8281526020909120546002161515610801565b610df6611810565b61099a816001611978565b610e09611810565b610e125f6119ea565b565b638b78c6d8600c908152335f526020902054600216610e5f576040517f27e1f1e500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b828114610e98576040517fa24a13a600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f0000000000000000000000007a18edfe055488a3128f01f563e5b479d92ffc3a73ffffffffffffffffffffffffffffffffffffffff163b5f03610f08576040517f5c0f897a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f0000000000000000000000007a18edfe055488a3128f01f563e5b479d92ffc3a73ffffffffffffffffffffffffffffffffffffffff16635c60da1b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610f71573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610f9591906123d1565b73ffffffffffffffffffffffffffffffffffffffff163b5f03610fe4576040517f5c0f897a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5b83811015610980575f30848484818110611002576110026120b2565b9050602002013560405160200161103b92919073ffffffffffffffffffffffffffffffffffffffff929092168252602082015260400190565b60405160208183030381529060405290505f61107f7f0000000000000000000000007a18edfe055488a3128f01f563e5b479d92ffc3a838480519060200120611a4f565b90508073ffffffffffffffffffffffffffffffffffffffff1663c4d66de88888868181106110af576110af6120b2565b90506020020160208101906110c49190611faf565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e084901b16815273ffffffffffffffffffffffffffffffffffffffff90911660048201526024015f604051808303815f87803b158015611127575f5ffd5b505af1158015611139573d5f5f3e3d5ffd5b5050505084848481811061114f5761114f6120b2565b90506020020135878785818110611168576111686120b2565b905060200201602081019061117d9190611faf565b60405173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000007a18edfe055488a3128f01f563e5b479d92ffc3a81168252918216918416907f7441de0ad639fe5d2bf1c22447715a0528b682385736bb40ae8dd92555eb82769060200160405180910390a45050600101610fe6565b611200611810565b73ffffffffffffffffffffffffffffffffffffffff811661124d576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff81165f8181526002602052604080822080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055517f02b73c10eecb635def7b11d92c9d82870141a7b0623e1e43f6eeabf202f310a49190a250565b604080513060208201529081018290525f9081906060016040516020818303038152906040529050610b617f00000000000000000000000058ca52ebe0dadfdf531cde7062e76746de4db1eb82838051906020012030611a64565b638b78c6d8600c9081525f8281526020909120546004161515610801565b638b78c6d8600c908152335f526020902054600116611387576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61099a816002611978565b638b78c6d8600c908152335f5260209020546001166113dd576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61099a816002611845565b638b78c6d8600c908152335f526020902054600116611433576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61099a816118f4565b611444611810565b61099a81611a87565b638b78c6d8600c908152335f526020902054600416611498576040517fb087c84600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8281146114d1576040517fa24a13a600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f00000000000000000000000058ca52ebe0dadfdf531cde7062e76746de4db1eb73ffffffffffffffffffffffffffffffffffffffff163b5f03611541576040517f5c0f897a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5b83811015610980575f3084848481811061155f5761155f6120b2565b9050602002013560405160200161159892919073ffffffffffffffffffffffffffffffffffffffff929092168252602082015260400190565b60405160208183030381529060405290505f6115dc7f00000000000000000000000058ca52ebe0dadfdf531cde7062e76746de4db1eb838480519060200120611b57565b90508073ffffffffffffffffffffffffffffffffffffffff1663c4d66de888888681811061160c5761160c6120b2565b90506020020160208101906116219190611faf565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e084901b16815273ffffffffffffffffffffffffffffffffffffffff90911660048201526024015f604051808303815f87803b158015611684575f5ffd5b505af1158015611696573d5f5f3e3d5ffd5b505050508484848181106116ac576116ac6120b2565b905060200201358787858181106116c5576116c56120b2565b90506020020160208101906116da9190611faf565b60405173ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000058ca52ebe0dadfdf531cde7062e76746de4db1eb81168252918216918416907f7441de0ad639fe5d2bf1c22447715a0528b682385736bb40ae8dd92555eb82769060200160405180910390a45050600101611543565b61175d611810565b63389a75e1600c52805f526020600c20805442111561178357636f5e88185f526004601cfd5b5f905561099a816119ea565b611797611810565b8060601b6117ac57637448fbae5f526004601cfd5b61099a816119ea565b604080513060208201529081018290525f9081906060016040516020818303038152906040529050610b617f0000000000000000000000007a18edfe055488a3128f01f563e5b479d92ffc3a82838051906020012030611b64565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927543314610e12576382b429005f526004601cfd5b610afd82825f611b70565b73ffffffffffffffffffffffffffffffffffffffff167fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927819055805f7f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08180a350565b638b78c6d8600c52815f52806020600c205580600c5160601c7f715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe265f5fa35050565b5f81118015611906575062093a808111155b61193c576040517fd726569900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60018190556040518181527fccbd249a1d0f1e2e065e09f062524aaa559476c9ec2e6c4783937ea8a16ee4dc906020015b60405180910390a150565b610afd82826001611b70565b307f000000000000000000000000528cc05efac2b0d255e423272187efd41248abd703610e1257610e12611bc7565b61099a611810565b307f000000000000000000000000528cc05efac2b0d255e423272187efd41248abd714610e1257610e12611bc7565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927805473ffffffffffffffffffffffffffffffffffffffff9092169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a355565b5f611a5c5f858585611bd4565b949350505050565b5f5f611a708686611c92565b9050611a7d818585611d3d565b9695505050505050565b73ffffffffffffffffffffffffffffffffffffffff81165f9081526002602052604090205460ff16611ae5576040517f5a80dc5600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f80547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527fab64f92ab780ecbf4f3866f57cee465ff36c89450dcce20237ca7a8d81fb7d139060200161196d565b5f611a5c5f858585611d5c565b5f5f611a708686611e01565b638b78c6d8600c52825f526020600c20805483811783611b91575080841681185b80835580600c5160601c7f715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe265f5fa3505050505050565b639f03a0265f526004601cfd5b5f604051835180608b8301826020880160045afa507fb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3606b8301527f1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c604b8301527660195155f3363d3d373d3d363d602036600436635c60da602b8301528560148301528060381b6afe6100523d8160233d39730161ffad821183015283607582016016840189f59250505080611a5c5763301164255f526004601cfd5b5f604051825161ffc281113d3d3e5f5b81811015611cbf5760208186018101516060858401015201611ca2565b507fcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f360408301527f5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e20766020830152616009601652846014528060381b6961003d3d8160233d3973015f5260165182526060810182209250505092915050565b5f60ff5f5350603592835260601b60015260155260555f908120915290565b5f60405183518060608301826020880160045afa507fcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f360408301527f5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e20766020830152616009601652856014528060381b6afe61003d3d8160233d39730161ffc2821152601651825283606082018389f59250505080611a5c5763301164255f526004601cfd5b5f604051825161ffad81113d3d3e5f5b81811015611e2e576020818601810151608b858401015201611e11565b507fb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3606b8301527f1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c604b8301527660195155f3363d3d373d3d363d602036600436635c60da602b8301528460148301528060381b696100523d8160233d39730182526075810160168301209250505092915050565b5f60208284031215611ed3575f5ffd5b5035919050565b5f5f83601f840112611eea575f5ffd5b50813567ffffffffffffffff811115611f01575f5ffd5b6020830191508360208260051b8501011115611f1b575f5ffd5b9250929050565b5f5f5f5f60408587031215611f35575f5ffd5b843567ffffffffffffffff811115611f4b575f5ffd5b611f5787828801611eda565b909550935050602085013567ffffffffffffffff811115611f76575f5ffd5b611f8287828801611eda565b95989497509550505050565b73ffffffffffffffffffffffffffffffffffffffff8116811461099a575f5ffd5b5f60208284031215611fbf575f5ffd5b8135610b6181611f8e565b5f5f5f60608486031215611fdc575f5ffd5b8335611fe781611f8e565b92506020840135611ff781611f8e565b929592945050506040919091013590565b5f5f60408385031215612019575f5ffd5b823561202481611f8e565b946020939093013593505050565b5f5f5f60408486031215612044575f5ffd5b833561204f81611f8e565b9250602084013567ffffffffffffffff81111561206a575f5ffd5b8401601f8101861361207a575f5ffd5b803567ffffffffffffffff811115612090575f5ffd5b8660208284010111156120a1575f5ffd5b939660209190910195509293505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f82357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81833603018112612111575f5ffd5b9190910192915050565b5f5f83357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe184360301811261214e575f5ffd5b83018035915067ffffffffffffffff821115612168575f5ffd5b602001915036819003821315611f1b575f5ffd5b81835281816020850137505f602082840101525f60207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116840101905092915050565b5f8383855260208501945060208460051b820101835f5b868110156122f4577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe084840301885281357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa187360301811261223a575f5ffd5b8601803561224781611f8e565b73ffffffffffffffffffffffffffffffffffffffff168452602081810135908501526040810135368290037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe101811261229e575f5ffd5b0160208101903567ffffffffffffffff8111156122b9575f5ffd5b8036038213156122c7575f5ffd5b606060408601526122dc60608601828461217c565b60209a8b019a909550939093019250506001016121da565b50909695505050505050565b604081525f843561231081611f8e565b73ffffffffffffffffffffffffffffffffffffffff166040838101919091526020860135606080850191909152908601356080840152850135368690037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1018112612379575f5ffd5b850160208101903567ffffffffffffffff811115612395575f5ffd5b8060051b36038213156123a6575f5ffd5b608060a08501526123bb60c0850182846121c3565b9150508281036020840152611a7d81858761217c565b5f602082840312156123e1575f5ffd5b8151610b6181611f8e56fea2646970667358221220b5494a84e0a41141dcde381487bab18b032293b25802163e11e78e1de1d8785364736f6c63430008220033","recompiledBytecode":"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","sourceMap":"6043:17293:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12741:125;;;;;;;;;;-1:-1:-1;12741:125:6;;;;;:::i;:::-;;:::i;:::-;;;421:42:10;409:55;;;391:74;;379:2;364:18;12741:125:6;;;;;;;;16022:327;;;;;;;;;;-1:-1:-1;16022:327:6;;;;;:::i;:::-;;:::i;:::-;;20049:102;;;;;;;;;;-1:-1:-1;20049:102:6;;;;;:::i;:::-;;:::i;9438:359::-;;;;;;;;;;-1:-1:-1;9438:359:6;;;;;:::i;:::-;;:::i;10291:109:1:-;;;;;;:::i;:::-;;:::i;9752:123::-;;;;;;:::i;:::-;;:::i;11342:139::-;;;;;;;;;;-1:-1:-1;11342:139:1;;;;;:::i;:::-;10933:15;10927:4;10920:29;;;11421:4;10962:18;;;;11062:4;11046:21;;;11040:28;11444:21;;:30;;11342:139;;;;3391:14:10;;3384:22;3366:41;;3354:2;3339:18;11342:139:1;3226:187:10;19136:129:6;;;;;;;;;;-1:-1:-1;19136:129:6;;;;;:::i;:::-;;:::i;12045:134::-;;;;;;;;;;-1:-1:-1;12045:134:6;;;;;:::i;:::-;;:::i;10904:113::-;;;;;;;;;;-1:-1:-1;10904:113:6;;;;;:::i;:::-;;:::i;9021:617:0:-;;;:::i;21395:204:6:-;;;;;;;;;;-1:-1:-1;21395:204:6;;;;;:::i;:::-;;:::i;7553:51::-;;;;;;;;;;;;7598:6;7553:51;;;;;3936:25:10;;;3924:2;3909:18;7553:51:6;3790:177:10;10731:353:1;;;;;;;;;;-1:-1:-1;10731:353:1;;;;;:::i;:::-;10933:15;10927:4;10920:29;;;10791:13;10962:18;;;;11062:4;11046:21;;11040:28;;10731:353;18855:125:6;;;;;;;;;;-1:-1:-1;18855:125:6;;;;;:::i;:::-;;:::i;7877:31::-;;;;;;;;;;;;;;;10020:125:1;;;;;;:::i;:::-;;:::i;3586:1618:5:-;;;;;;:::i;:::-;;:::i;11146:134:1:-;;;;;;;;;;-1:-1:-1;11146:134:1;;;;;:::i;:::-;10933:15;10927:4;10920:29;;;11224:4;10962:18;;;;11062:4;11046:21;;;11040:28;11247:21;:26;;;11146:134;3153:227:5;;;;;;;;;;;;;:::i;7250:56:6:-;;;;;;;;;;-1:-1:-1;7250:56:6;;;;;:::i;:::-;;;;;;;;;;;;;;;;9720:456:0;;;:::i;6659:29:6:-;;;;;;;;;;-1:-1:-1;6659:29:6;;;;;;;;11195:122;;;;;;;;;;-1:-1:-1;11195:122:6;;;;;:::i;:::-;;:::i;19824:98::-;;;;;;;;;;-1:-1:-1;19824:98:6;;;;;:::i;:::-;;:::i;8762:100:0:-;;;:::i;14502:1114:6:-;;;;;;;;;;-1:-1:-1;14502:1114:6;;;;;:::i;:::-;;:::i;20880:269::-;;;;;;;;;;-1:-1:-1;20880:269:6;;;;;:::i;:::-;;:::i;13365:282::-;;;;;;;;;;-1:-1:-1;13365:282:6;;;;;:::i;:::-;;:::i;11514:140::-;;;;;;;;;;-1:-1:-1;11514:140:6;;;;;:::i;:::-;;:::i;11408:182:0:-;;;;;;;;;;-1:-1:-1;11562:11:0;11556:18;11408:182;;18354:107:6;;;;;;;;;;-1:-1:-1;18354:107:6;;;;;:::i;:::-;;:::i;8168:36::-;;;;;;;;;;;;;;;18597:111;;;;;;;;;;-1:-1:-1;18597:111:6;;;;;:::i;:::-;;:::i;19406:119::-;;;;;;;;;;-1:-1:-1;19406:119:6;;;;;:::i;:::-;;:::i;20455:123::-;;;;;;;;;;-1:-1:-1;20455:123:6;;;;;:::i;:::-;;:::i;6844:28::-;;;;;;;;;;;;;;;;17311:735;;;;;;;;;;-1:-1:-1;17311:735:6;;;;;:::i;:::-;;:::i;10363:708:0:-;;;;;;:::i;:::-;;:::i;8348:349::-;;;;;;:::i;:::-;;:::i;11693:435::-;;;;;;;;;;-1:-1:-1;11693:435:0;;;;;:::i;:::-;11963:19;11957:4;11950:33;;;11812:14;11996:26;;;;12106:4;12090:21;;12084:28;;11693:435;12741:125:6;12807:7;12833:26;12855:3;12833:21;:26::i;:::-;12826:33;12741:125;-1:-1:-1;;12741:125:6:o;16022:327::-;10933:15:1;10927:4;10920:29;;;10293:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12847:6;11247:21;10274:56:6;;;;;;;;;;;;;;;;;16134:37;;::::1;16126:69;;;;;;;;;;;;;;;;;16210:9;16205:138;16221:19:::0;;::::1;16205:138;;;16276:8;;16285:1;16276:11;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:18;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;16261:42;;;16304:8;;16313:1;16304:11;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;16317;;16329:1;16317:14;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;16261:71;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16242:3;;;;;16205:138;;;;16022:327:::0;;;;:::o;20049:102::-;12517:13:0;:11;:13::i;:::-;20115:29:6::1;20128:6;12799::1;20115:12:6;:29::i;:::-;20049:102:::0;:::o;9438:359::-;2002:66:3;3769:8;;3867:1;3857:12;;3951:398;;;;4111:1;4107;4104;4100:9;4097:16;4085:9;4073:22;4070:44;4060:189;;4151:10;4145:4;4138:24;4226:4;4220;4213:18;4060:189;4288:1;4284;4279:3;4275:11;4271:19;4266:24;;3951:398;-1:-1:-1;9573:20:6::1;::::0;::::1;9565:51;;;;;;;;;;;;;;;;;9634:20;::::0;::::1;9626:51;;;;;;;;;;;;;;;;;9687:24;9704:6;9687:16;:24::i;:::-;9721:26;9731:6;12799::1;9721:9:6;:26::i;:::-;9757:33;9775:14;9757:17;:33::i;:::-;4448:1:3::0;4445:264;;;4549:1;4546;4539:12;4630:1;4624:4;4617:15;4666:28;4660:4;4654;4649:46;4445:264;4431:288;9438:359:6;;;:::o;10291:109:1:-;10362:31;10375:10;10387:5;10362:12;:31::i;9752:123::-;12517:13:0;:11;:13::i;:::-;9844:24:1::1;9856:4;9862:5;9844:11;:24::i;:::-;9752:123:::0;;:::o;19136:129:6:-;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;19220:38:::1;19233:15;12895:6:1;19220:12:6;:38::i;12045:134::-:0;12120:7;12146:26;12168:3;12146:21;:26::i;:::-;12139:33;12045:134;-1:-1:-1;;;12045:134:6:o;10904:113::-;10933:15:1;10927:4;10920:29;;;10960:4:6;10962:18:1;;;11062:4;11046:21;;;11040:28;12799:6;11247:21;:26;;10983:27:6;11146:134:1;9021:617:0;9114:15;7972:9;9132:46;;:15;:46;9114:64;;9346:19;9340:4;9333:33;9396:8;9390:4;9383:22;9452:7;9445:4;9439;9429:21;9422:38;9599:8;9552:45;9549:1;9546;9541:67;9248:374;9021:617::o;21395:204:6:-;12517:13:0;:11;:13::i;:::-;21484:41:6::1;::::0;::::1;21528:5;21484:41:::0;;;:24:::1;:41;::::0;;;;;:49;;;::::1;::::0;;21549:43;::::1;::::0;21528:5;21549:43:::1;21395:204:::0;:::o;18855:125::-;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;18936:37:::1;18948:15;12895:6:1;18936:11:6;:37::i;10020:125:1:-:0;12517:13:0;:11;:13::i;:::-;10113:25:1::1;10126:4;10132:5;10113:12;:25::i;3586:1618:5:-:0;3720:17:2;:15;:17::i;:::-;3739:36:5::1;3757:17;3739;:36::i;:::-;3888:17;3884:2;3880:26;3876:2;3872:35;3851:56;;3958:16;3952:4;3945:30;4001:10;3995:4;3988:24;4056:28;4261:1;4253:4;4247;4241;4235;4216:17;4209:5;4198:60;4192:67;4189:74;4179:199;;4296:10;4290:4;4283:24;4359:4;4353;4346:18;4179:199;4483:17;4456:25;4450:4;4438:10;4433:68;4514:28:::0;;;4672:516;::::1;;;4800:4;4794:11;4851;4838;4835:1;4822:41;4957:4;4945:10;4932:11;4929:1;4910:17;4903:5;4890:72;4880:294;;5091:16;5085:4;5082:1;5067:41;5139:16;5136:1;5129:27;4672:516;3586:1618:::0;;;:::o;3153:227::-;3220:7;3930:20:2;:18;:20::i;:::-;-1:-1:-1;2188:66:5::1;3153:227:::0;:::o;9720:456:0:-;9922:19;9916:4;9909:33;9968:8;9962:4;9955:22;10020:1;10013:4;10007;9997:21;9990:32;10151:8;10105:44;10102:1;10099;10094:66;9720:456::o;11195:122:6:-;10933:15:1;10927:4;10920:29;;;11257:4:6;10962:18:1;;;11062:4;11046:21;;;11040:28;12847:6;11247:21;:26;;11280:30:6;11146:134:1;19824:98:6;12517:13:0;:11;:13::i;:::-;19887:28:6::1;19899:6;12799::1;19887:11:6;:28::i;8762:100:0:-:0;12517:13;:11;:13::i;:::-;8834:21:::1;8852:1;8834:9;:21::i;:::-;8762:100::o:0;14502:1114:6:-;10933:15:1;10927:4;10920:29;;;10293:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12847:6;11247:21;10274:56:6;;;;;;;;;;;;;;;;;14611:29;;::::1;14603:61;;;;;;;;;;;;;;;;;15073:6;:18;;;15095:1;15073:23:::0;15065:61:::1;;;;;;;;;;;;;;;;;15152:6;15144:30;;;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;;;15192:1;15144:49:::0;15136:87:::1;;;;;;;;;;;;;;;;;15239:9;15234:376;15250:18:::0;;::::1;15234:376;;;15289:17;15328:4;15335;;15340:1;15335:7;;;;;;;:::i;:::-;;;;;;;15309:34;;;;;;;;10890:42:10::0;10878:55;;;;10860:74;;10965:2;10950:18;;10943:34;10848:2;10833:18;;10686:297;15309:34:6::1;;;;;;;;;;;;;15289:54;;15358:14;15391:77;15438:6;15446:4;15462;15452:15;;;;;;15391:46;:77::i;:::-;15358:110;;15498:6;15483:33;;;15517:7;;15525:1;15517:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;15483:45;::::0;;::::1;::::0;;;;;;421:42:10;409:55;;;15483:45:6::1;::::0;::::1;391:74:10::0;364:18;;15483:45:6::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15583:4;;15588:1;15583:7;;;;;;;:::i;:::-;;;;;;;15571;;15579:1;15571:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;15548:51;::::0;::::1;15592:6;409:55:10::0;;391:74;;15548:51:6;;::::1;::::0;;::::1;::::0;::::1;::::0;379:2:10;364:18;15548:51:6::1;;;;;;;-1:-1:-1::0;;15270:3:6::1;;15234:376;;20880:269:::0;12517:13:0;:11;:13::i;:::-;20975:29:6::1;::::0;::::1;20967:60;;;;;;;;;;;;;;;;;21037:41;::::0;::::1;;::::0;;;:24:::1;:41;::::0;;;;;:48;;;::::1;21081:4;21037:48;::::0;;21101:41;::::1;::::0;21037;21101::::1;20880:269:::0;:::o;13365:282::-;13476:30;;;13495:4;13476:30;;;10860:74:10;10950:18;;;10943:34;;;13437:7:6;;;;10833:18:10;;13476:30:6;;;;;;;;;;;;13456:50;;13524:116;13581:11;13594:4;13610;13600:15;;;;;;13625:4;13524:43;:116::i;11514:140::-;10933:15:1;10927:4;10920:29;;;11588:4:6;10962:18:1;;;11062:4;11046:21;;;11040:28;12895:6;11247:21;:26;;11611:36:6;11146:134:1;18354:107:6;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;18423:31:::1;18435:9;12847:6:1;18423:11:6;:31::i;18597:111::-:0;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;18669:32:::1;18682:9;12847:6:1;18669:12:6;:32::i;19406:119::-:0;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;19485:33:::1;19503:14;19485:17;:33::i;20455:123::-:0;12517:13:0;:11;:13::i;:::-;20536:35:6::1;20555:15;20536:18;:35::i;17311:735::-:0;10933:15:1;10927:4;10920:29;;;10496:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12895:6;11247:21;10477:62:6;;;;;;;;;;;;;;;;;17452:29;;::::1;17444:61;;;;;;;;;;;;;;;;;17612:11;:23;;;17639:1;17612:28:::0;17604:66:::1;;;;;;;;;;;;;;;;;17686:9;17681:359;17697:18:::0;;::::1;17681:359;;;17736:17;17775:4;17782;;17787:1;17782:7;;;;;;;:::i;:::-;;;;;;;17756:34;;;;;;;;10890:42:10::0;10878:55;;;;10860:74;;10965:2;10950:18;;10943:34;10848:2;10833:18;;10686:297;17756:34:6::1;;;;;;;;;;;;;17736:54;;17805:14;17822:71;17858:11;17871:4;17887;17877:15;;;;;;17822:35;:71::i;:::-;17805:88;;17923:6;17908:33;;;17942:7;;17950:1;17942:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;17908:45;::::0;;::::1;::::0;;;;;;421:42:10;409:55;;;17908:45:6::1;::::0;::::1;391:74:10::0;364:18;;17908:45:6::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18008:4;;18013:1;18008:7;;;;;;;:::i;:::-;;;;;;;17996;;18004:1;17996:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;17973:56;::::0;::::1;18017:11;409:55:10::0;;391:74;;17973:56:6;;::::1;::::0;;::::1;::::0;::::1;::::0;379:2:10;364:18;17973:56:6::1;;;;;;;-1:-1:-1::0;;17717:3:6::1;;17681:359;;10363:708:0::0;12517:13;:11;:13::i;:::-;10597:19:::1;10591:4;10584:33;10643:12;10637:4;10630:26;10705:4;10699;10689:21;10811:12;10805:19;10792:11;10789:36;10786:157;;;10857:10;10851:4;10844:24;10924:4;10918;10911:18;10786:157;11020:1;10999:23:::0;;11041::::1;11051:12:::0;11041:9:::1;:23::i;8348:349::-:0;12517:13;:11;:13::i;:::-;8520:8:::1;8516:2;8512:17;8502:150;;8562:10;8556:4;8549:24;8633:4;8627;8620:18;8502:150;8671:19;8681:8;8671:9;:19::i;23051:283:6:-:0;23157:30;;;23176:4;23157:30;;;10860:74:10;10950:18;;;10943:34;;;23118:7:6;;;;10833:18:10;;23157:30:6;;;;;;;;;;;;23137:50;;23205:122;23273:6;23281:4;23297;23287:15;;;;;;23312:4;23205:54;:122::i;7292:355:0:-;7504:11;7498:18;7488:8;7485:32;7475:156;;7550:10;7544:4;7537:24;7612:4;7606;7599:18;4468:117:1;4546:32;4559:4;4565:5;4572;4546:12;:32::i;4883:1190:0:-;5793:26;;5883:11;5876:29;;;5793:26;6031:1;5991:38;6031:1;;5980:63;4883:1190;:::o;2478:432:1:-;2632:15;2626:4;2619:29;2674:4;2668;2661:18;2758:5;2751:4;2745;2735:21;2728:36;2888:5;2880:4;2874:11;2870:2;2866:20;2834:30;2831:1;2828;2823:71;2478:432;;:::o;22598:256:6:-;22693:1;22676:14;:18;:58;;;;;7598:6;22698:14;:36;;22676:58;22668:91;;;;;;;;;;;;;;;;;22769:13;:30;;;22815:32;;3936:25:10;;;22815:32:6;;3924:2:10;3909:18;22815:32:6;;;;;;;;22598:256;:::o;4217:115:1:-;4294:31;4307:4;4313:5;4320:4;4294:12;:31::i;3017:123:2:-;2687:4;2661:6;:32;3076:57;;3101:32;:30;:32::i;21863:66:6:-;12517:13:0;:11;:13::i;3278:127:2:-;2687:4;2661:6;:32;3340:58;;3366:32;:30;:32::i;6145:1089:0:-;6857:11;7093:16;;6941:26;;;;;;;7053:38;7050:1;;7042:78;7177:27;6145:1089::o;114499:240:4:-;114629:16;114672:60;114710:1;114713:6;114721:4;114727;114672:37;:60::i;:::-;114661:71;114499:240;-1:-1:-1;;;;114499:240:4:o;61913:343::-;62093:17;62122:12;62137:41;62157:14;62173:4;62137:19;:41::i;:::-;62122:56;;62200:49;62228:4;62234;62240:8;62200:27;:49::i;:::-;62188:61;61913:343;-1:-1:-1;;;;;;61913:343:4:o;22205:252:6:-;22285:41;;;;;;;:24;:41;;;;;;;;22277:81;;;;;;;;;;;;;;;;;22368:14;:32;;;;;;;;;;;;;22416:34;;391:74:10;;;22416:34:6;;379:2:10;364:18;22416:34:6;245:226:10;55028:234:4;55155:16;55198:57;55225:1;55228:14;55244:4;55250;55198:26;:57::i;121466:349::-;121649:17;121678:12;121693:44;121724:6;121732:4;121693:30;:44::i;3116:967:1:-;3282:15;3276:4;3269:29;3324:4;3318;3311:18;3374:4;3368;3358:21;3452:8;3446:15;3559:5;3550:7;3547:18;3803:2;3793:62;;-1:-1:-1;3833:19:1;;;3820:33;;3793:62;3927:7;3917:8;3910:25;4059:7;4051:4;4045:11;4041:2;4037:20;4005:30;4002:1;3999;3994:73;;;;3116:967;;;:::o;4257:234:2:-;4401:10;4395:4;4388:24;4470:4;4464;4457:18;114883:1125:4;115050:16;115159:4;115153:11;115192:4;115186:11;115269:1;115262:4;115259:1;115255:12;115252:1;115245:4;115239;115235:15;115232:1;115225:5;115214:57;115210:62;115306:66;115299:4;115296:1;115292:12;115285:88;115407:66;115400:4;115397:1;115393:12;115386:88;115508:48;115501:4;115498:1;115494:12;115487:70;115591:6;115584:4;115581:1;115577:12;115570:28;115766:1;115762:2;115758:10;115732:24;115728:41;115718:6;115715:1;115712:13;115709:1;115705:21;115698:72;115838:4;115831;115828:1;115824:12;115817:4;115814:1;115810:12;115803:5;115795:48;115783:60;;;;115866:8;115856:136;;115907:10;115901:4;115894:24;115973:4;115967;115960:18;60678:1026;60797:12;60906:4;60900:11;60939:4;60933:11;61101:6;61098:1;61095:13;61077:16;61059;61044:65;61137:1;61122:142;61147:1;61144;61141:8;61122:142;;;61239:4;61225:23;;;;;61219:30;61208:4;61197:20;;;;61190:60;61157:12;61122:142;;;61126:14;61298:66;61291:4;61288:1;61284:12;61277:88;61399:66;61392:4;61389:1;61385:12;61378:88;61492:6;61486:4;61479:20;61525:14;61519:4;61512:28;61602:1;61598:2;61594:10;61570:22;61566:39;61560:4;61553:53;61635:4;61629:11;61626:1;61619:22;61682:4;61679:1;61675:12;61672:1;61662:26;61654:34;;;;60678:1026;;;;:::o;154939:578::-;155069:17;155234:4;155228;155220:19;-1:-1:-1;155280:4:4;155273:18;;;155321:2;155317:17;155311:4;155304:31;155355:4;155348:18;155408:4;155402;155392:21;;;155426:15;;155392:21;154939:578::o;55417:1088::-;55581:16;55690:4;55684:11;55723:4;55717:11;55800:1;55793:4;55790:1;55786:12;55783:1;55776:4;55770;55766:15;55763:1;55756:5;55745:57;55741:62;55837:66;55830:4;55827:1;55823:12;55816:88;55938:66;55931:4;55928:1;55924:12;55917:88;56031:6;56025:4;56018:20;56064:14;56058:4;56051:28;56239:1;56235:2;56231:10;56205:24;56201:41;56192:6;56189:1;56186:13;56179:64;56272:4;56266:11;56263:1;56256:22;56335:4;56328;56325:1;56321:12;56318:1;56311:5;56303:37;56291:49;;;;56363:8;56353:136;;56404:10;56398:4;56391:24;56470:4;56464;56457:18;120214:1052;120336:12;120445:4;120439:11;120478:4;120472:11;120640:6;120637:1;120634:13;120616:16;120598;120583:65;120676:1;120661:142;120686:1;120683;120680:8;120661:142;;;120778:4;120764:23;;;;;120758:30;120747:4;120736:20;;;;120729:60;120696:12;120661:142;;;120665:14;120837:66;120830:4;120827:1;120823:12;120816:88;120938:66;120931:4;120928:1;120924:12;120917:88;121039:48;121032:4;121029:1;121025:12;121018:70;121122:6;121115:4;121112:1;121108:12;121101:28;121188:1;121184:2;121180:10;121156:22;121152:39;121149:1;121142:50;121244:4;121241:1;121237:12;121230:4;121227:1;121223:12;121213:37;121205:45;;;;120214:1052;;;;:::o;14:226:10:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;187:23:10;;14:226;-1:-1:-1;14:226:10:o;476:381::-;553:8;563:6;617:3;610:4;602:6;598:17;594:27;584:55;;635:1;632;625:12;584:55;-1:-1:-1;658:20:10;;701:18;690:30;;687:50;;;733:1;730;723:12;687:50;770:4;762:6;758:17;746:29;;830:3;823:4;813:6;810:1;806:14;798:6;794:27;790:38;787:47;784:67;;;847:1;844;837:12;784:67;476:381;;;;;:::o;862:832::-;1020:6;1028;1036;1044;1097:2;1085:9;1076:7;1072:23;1068:32;1065:52;;;1113:1;1110;1103:12;1065:52;1153:9;1140:23;1186:18;1178:6;1175:30;1172:50;;;1218:1;1215;1208:12;1172:50;1257:84;1333:7;1324:6;1313:9;1309:22;1257:84;:::i;:::-;1360:8;;-1:-1:-1;1231:110:10;-1:-1:-1;;1448:2:10;1433:18;;1420:32;1477:18;1464:32;;1461:52;;;1509:1;1506;1499:12;1461:52;1548:86;1626:7;1615:8;1604:9;1600:24;1548:86;:::i;:::-;862:832;;;;-1:-1:-1;1653:8:10;-1:-1:-1;;;;862:832:10:o;1699:154::-;1785:42;1778:5;1774:54;1767:5;1764:65;1754:93;;1843:1;1840;1833:12;1858:247;1917:6;1970:2;1958:9;1949:7;1945:23;1941:32;1938:52;;;1986:1;1983;1976:12;1938:52;2025:9;2012:23;2044:31;2069:5;2044:31;:::i;2110:508::-;2187:6;2195;2203;2256:2;2244:9;2235:7;2231:23;2227:32;2224:52;;;2272:1;2269;2262:12;2224:52;2311:9;2298:23;2330:31;2355:5;2330:31;:::i;:::-;2380:5;-1:-1:-1;2437:2:10;2422:18;;2409:32;2450:33;2409:32;2450:33;:::i;:::-;2110:508;;2502:7;;-1:-1:-1;;;2582:2:10;2567:18;;;;2554:32;;2110:508::o;2854:367::-;2922:6;2930;2983:2;2971:9;2962:7;2958:23;2954:32;2951:52;;;2999:1;2996;2989:12;2951:52;3038:9;3025:23;3057:31;3082:5;3057:31;:::i;:::-;3107:5;3185:2;3170:18;;;;3157:32;;-1:-1:-1;;;2854:367:10:o;3972:721::-;4051:6;4059;4067;4120:2;4108:9;4099:7;4095:23;4091:32;4088:52;;;4136:1;4133;4126:12;4088:52;4175:9;4162:23;4194:31;4219:5;4194:31;:::i;:::-;4244:5;-1:-1:-1;4300:2:10;4285:18;;4272:32;4327:18;4316:30;;4313:50;;;4359:1;4356;4349:12;4313:50;4382:22;;4435:4;4427:13;;4423:27;-1:-1:-1;4413:55:10;;4464:1;4461;4454:12;4413:55;4504:2;4491:16;4530:18;4522:6;4519:30;4516:50;;;4562:1;4559;4552:12;4516:50;4607:7;4602:2;4593:6;4589:2;4585:15;4581:24;4578:37;4575:57;;;4628:1;4625;4618:12;4575:57;3972:721;;4659:2;4651:11;;;;;-1:-1:-1;4681:6:10;;-1:-1:-1;;;3972:721:10:o;5681:184::-;5733:77;5730:1;5723:88;5830:4;5827:1;5820:15;5854:4;5851:1;5844:15;5870:381;5961:4;6019:11;6006:25;6109:66;6098:8;6082:14;6078:29;6074:102;6054:18;6050:127;6040:155;;6191:1;6188;6181:12;6040:155;6212:33;;;;;5870:381;-1:-1:-1;;5870:381:10:o;6256:580::-;6333:4;6339:6;6399:11;6386:25;6489:66;6478:8;6462:14;6458:29;6454:102;6434:18;6430:127;6420:155;;6571:1;6568;6561:12;6420:155;6598:33;;6650:20;;;-1:-1:-1;6693:18:10;6682:30;;6679:50;;;6725:1;6722;6715:12;6679:50;6758:4;6746:17;;-1:-1:-1;6789:14:10;6785:27;;;6775:38;;6772:58;;;6826:1;6823;6816:12;6841:325;6929:6;6924:3;6917:19;6981:6;6974:5;6967:4;6962:3;6958:14;6945:43;;7033:1;7026:4;7017:6;7012:3;7008:16;7004:27;6997:38;6899:3;7155:4;7085:66;7080:2;7072:6;7068:15;7064:88;7059:3;7055:98;7051:109;7044:116;;6841:325;;;;:::o;7171:1819::-;7254:3;7285;7309:6;7304:3;7297:19;7341:4;7336:3;7332:14;7325:21;;7399:4;7389:6;7386:1;7382:14;7375:5;7371:26;7367:37;7427:5;7450:1;7460:1504;7474:6;7471:1;7468:13;7460:1504;;;7557:66;7549:5;7543:4;7539:16;7535:89;7530:3;7523:102;7677:6;7664:20;7763:66;7755:5;7739:14;7735:26;7731:99;7711:18;7707:124;7697:152;;7845:1;7842;7835:12;7697:152;7877:30;;7935:21;;7969:33;7935:21;7969:33;:::i;:::-;8041:42;8028:56;8015:70;;8164:4;8151:18;;;8138:32;8190:15;;;8183:32;8282:4;8269:18;;8256:32;8345:14;8341:28;;;8371:66;8337:101;8311:128;;8301:156;;8453:1;8450;8443:12;8301:156;8485:34;8610:4;8597:18;;;8548:21;8644:18;8631:32;;8628:52;;;8676:1;8673;8666:12;8628:52;8729:8;8713:14;8709:29;8700:7;8696:43;8693:63;;;8752:1;8749;8742:12;8693:63;8793:4;8786;8780;8776:15;8769:29;8819:61;8874:4;8868;8864:15;8854:8;8845:7;8819:61;:::i;:::-;8915:4;8940:14;;;;8811:69;;-1:-1:-1;8903:17:10;;;;;-1:-1:-1;;7496:1:10;7489:9;7460:1504;;;-1:-1:-1;8980:4:10;;7171:1819;-1:-1:-1;;;;;;7171:1819:10:o;8995:1430::-;9228:2;9217:9;9210:21;9191:4;9266:6;9253:20;9282:31;9307:5;9282:31;:::i;:::-;9360:42;9349:54;9344:2;9329:18;;;9322:82;;;;9474:4;9462:17;;9449:31;9511:2;9496:18;;;9489:35;;;;9582:15;;;9569:29;9629:4;9614:20;;9607:37;9692:15;;9679:29;9759:14;9755:27;;;9784:66;9751:100;9727:125;;9717:153;;9866:1;9863;9856:12;9717:153;9894:31;;10006:4;9993:18;;;9948:21;10034:18;10023:30;;10020:50;;;10066:1;10063;10056:12;10020:50;10122:6;10119:1;10115:14;10099;10095:35;10086:7;10082:49;10079:69;;;10144:1;10141;10134:12;10079:69;10185:4;10179:3;10168:9;10164:19;10157:33;10210:88;10293:3;10282:9;10278:19;10270:6;10261:7;10210:88;:::i;:::-;10199:99;;;10345:9;10340:3;10336:19;10329:4;10318:9;10314:20;10307:49;10373:46;10415:3;10407:6;10399;10373:46;:::i;10430:251::-;10500:6;10553:2;10541:9;10532:7;10528:23;10524:32;10521:52;;;10569:1;10566;10559:12;10521:52;10601:9;10595:16;10620:31;10645:5;10620:31;:::i","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220b5494a84e0a41141dcde381487bab18b032293b25802163e11e78e1de1d8785364736f6c63430008220033","offset":9197}},"immutableReferences":{"1739":[{"start":6535,"length":32},{"start":6590,"length":32}],"4152":[{"start":1238,"length":32},{"start":3738,"length":32},{"start":3850,"length":32},{"start":4178,"length":32},{"start":4503,"length":32},{"start":6114,"length":32}],"4155":[{"start":1773,"length":32},{"start":4848,"length":32},{"start":5331,"length":32},{"start":5551,"length":32},{"start":5876,"length":32}]},"transformations":[{"id":"4152","type":"replace","offset":1238,"reason":"immutable"},{"id":"4155","type":"replace","offset":1773,"reason":"immutable"},{"id":"4152","type":"replace","offset":3738,"reason":"immutable"},{"id":"4152","type":"replace","offset":3850,"reason":"immutable"},{"id":"4152","type":"replace","offset":4178,"reason":"immutable"},{"id":"4152","type":"replace","offset":4503,"reason":"immutable"},{"id":"4155","type":"replace","offset":4848,"reason":"immutable"},{"id":"4155","type":"replace","offset":5331,"reason":"immutable"},{"id":"4155","type":"replace","offset":5551,"reason":"immutable"},{"id":"4155","type":"replace","offset":5876,"reason":"immutable"},{"id":"4152","type":"replace","offset":6114,"reason":"immutable"},{"id":"1739","type":"replace","offset":6535,"reason":"immutable"},{"id":"1739","type":"replace","offset":6590,"reason":"immutable"}],"transformationValues":{"immutables":{"1739":"0x000000000000000000000000528cc05efac2b0d255e423272187efd41248abd7","4152":"0x0000000000000000000000007a18edfe055488a3128f01f563e5b479d92ffc3a","4155":"0x00000000000000000000000058ca52ebe0dadfdf531cde7062e76746de4db1eb"}}},"deployment":{"transactionHash":"0x50904d375b41b943df353c7939fb1737ce973bdc1a54534847e156e3095c1cd2","blockNumber":"89493253","transactionIndex":"45","deployer":"0xcA71EA69c54c163D17beB90BeB8D001E1Eb538A1"},"sources":{"src/DepositWalletFactory.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.34;\n\nimport {OwnableRoles} from \"@solady/src/auth/OwnableRoles.sol\";\nimport {Initializable} from \"@solady/src/utils/Initializable.sol\";\nimport {LibClone} from \"@solady/src/utils/LibClone.sol\";\nimport {UUPSUpgradeable} from \"@solady/src/utils/UUPSUpgradeable.sol\";\n\nimport {Errors} from \"@deposit-wallet/src/Errors.sol\";\nimport {IDepositWallet, Batch} from \"@deposit-wallet/src/interfaces/IDepositWallet.sol\";\n\n/// @notice Minimal interface for resolving a beacon's current implementation.\ninterface IBeacon {\n    /// @notice Returns the implementation the beacon currently resolves to.\n    function implementation() external view returns (address);\n}\n\n/// @title DepositWalletFactoryErrors\n/// @author Polymarket\n/// @notice Custom errors for {DepositWalletFactory}.\nabstract contract DepositWalletFactoryErrors {\n    /// @notice Thrown when the caller does not have the admin role.\n    error OnlyAdmin();\n\n    /// @notice Thrown when the caller does not have the operator role.\n    error OnlyOperator();\n\n    /// @notice Thrown when the caller does not have the legacy-deployer role.\n    error OnlyLegacyDeployer();\n\n    /// @notice Thrown when paired input arrays have mismatched lengths.\n    error ArrayLengthMismatch();\n\n    /// @notice Thrown when an implementation has not been authorized.\n    /// @dev Deprecated post-migration; only thrown by the legacy {setImplementation} surface.\n    error ImplementationNotAuthorized();\n\n    /// @notice Thrown when the provided timelock delay is zero or exceeds the maximum.\n    error InvalidTimelockDelay();\n\n    /// @notice Thrown when a deploy target (the beacon, its resolved implementation, or the\n    ///         legacy implementation) has no code.\n    /// @dev Fail-closed guard: deploying a proxy whose implementation/beacon is code-less would\n    ///      let `initialize` silently succeed as a delegatecall to an empty account, minting an\n    ///      ownerless wallet that anyone could later seize.\n    error ImplementationNotDeployed();\n}\n\n/// @title DepositWalletFactoryEvents\n/// @author Polymarket\n/// @notice Events emitted by {DepositWalletFactory}.\nabstract contract DepositWalletFactoryEvents {\n    /// @notice Emitted when a wallet implementation is added to the authorized set.\n    /// @dev Deprecated post-migration; only emitted while the legacy upgrade surface is in use\n    ///      (e.g., authorizing {BeaconForwarder}).\n    /// @param implementation The address of the authorized implementation.\n    event ImplementationAuthorized(address indexed implementation);\n\n    /// @notice Emitted when the default wallet implementation is updated.\n    /// @dev Deprecated; the legacy slot-0 `implementation` pointer is no longer consulted by\n    ///      {DepositWalletFactory.deploy}.\n    /// @param Implementation The address of the new default implementation.\n    event ImplementationSet(address Implementation);\n\n    /// @notice Emitted when a wallet implementation is removed from the authorized set.\n    /// @dev Deprecated post-migration; only emitted while the legacy upgrade surface is in use.\n    /// @param implementation The address of the unauthorized implementation.\n    event ImplementationUnauthorized(address indexed implementation);\n\n    /// @notice Emitted when the timelock delay is updated.\n    /// @param timelockDelay The new timelock delay in seconds.\n    event TimelockDelaySet(uint256 timelockDelay);\n\n    /// @notice Emitted when a new deposit wallet is deployed.\n    /// @param wallet The address of the newly deployed wallet proxy.\n    /// @param owner The initial owner of the wallet.\n    /// @param id The unique identifier assigned to the wallet.\n    /// @param implementation The address embedded in the proxy: the beacon for beacon-shape\n    ///                       wallets, or the legacy implementation for legacy-shape wallets.\n    event WalletDeployed(\n        address indexed wallet, address indexed owner, bytes32 indexed id, address implementation\n    );\n}\n\n/// @title DepositWalletFactory\n/// @author Polymarket\n/// @notice Factory contract for deploying and managing DepositWallets. Deploys ERC-1967\n///         beacon proxies going forward, and can also deploy legacy ERC-1967 (UUPS-shaped)\n///         wallets at the exact deterministic addresses the pre-beacon factory used.\n/// @dev Uses a four-tier role model:\n///      - **Owner**: can add/remove admins, manage implementations, and authorize UUPS upgrades\n///                   of the factory itself.\n///      - **Admin** (ROLE_0): can add/remove operators and legacy deployers, and configure the\n///                   timelock delay.\n///      - **Operator** (ROLE_1): can deploy beacon-shape wallets and proxy batch executions.\n///      - **Legacy deployer** (ROLE_2): can deploy legacy-shape wallets via {deployLegacy}.\n///\n///      Two deploy paths, fed identical `args`/`salt`:\n///      - {deploy} produces an ERC-1967 beacon proxy bound to {BEACON}.\n///      - {deployLegacy} produces a plain ERC-1967 proxy embedding {LEGACY_IMPL}. This reproduces\n///        the exact addresses the pre-beacon factory derived, because the address depends only on\n///        (this factory's address, the embedded implementation, the Solady proxy template, the\n///        id) — never on this factory's own bytecode. It exists for ids whose legacy address has\n///        already been handed out, and for cross-chain recovery: deployed at the canonical\n///        factory address on another chain, it mints a wallet at the identical address a user's\n///        Polygon deposit wallet occupies.\n///\n///      Both paths fail closed: they revert unless the embedded implementation/beacon already\n///      holds code, so a misordered rollout cannot mint ownerless, seizable wallets.\n///\n///      Storage slots 0/1/2 (`implementation`, `timelockDelay`, `authorizedImplementation`) are\n///      preserved from prior versions so this contract can be installed as a UUPS upgrade on the\n///      live factory proxy without corrupting state.\ncontract DepositWalletFactory is\n    OwnableRoles,\n    Initializable,\n    UUPSUpgradeable,\n    DepositWalletFactoryErrors,\n    DepositWalletFactoryEvents\n{\n    /*--------------------------------------------------------------\n                                 STATE\n    --------------------------------------------------------------*/\n\n    /// @notice Legacy default wallet implementation pointer.\n    /// @dev Deprecated; not consulted by {deploy} or {deployLegacy}. Retained only to preserve\n    ///      slot 0 of the live factory proxy so this contract can be installed via UUPS upgrade\n    ///      in place.\n    address public implementation;\n\n    /// @notice The delay in seconds that must elapse after pausing before the owner can\n    ///         execute paused-only operations on a wallet.\n    uint256 public timelockDelay;\n\n    /// @notice Tracks which implementation addresses are authorized for legacy UUPS upgrades.\n    /// @dev Legacy-shape wallets gate their `upgrade` self-call on this mapping. Used during the\n    ///      migration window to authorize {BeaconForwarder} so existing UUPS wallets can opt into\n    ///      the beacon. Will be deprecated after the migration window closes.\n    mapping(address => bool) public authorizedImplementation;\n\n    /*--------------------------------------------------------------\n                              CONSTANTS\n    --------------------------------------------------------------*/\n\n    /// @notice The maximum allowed timelock delay (7 days).\n    uint256 public constant MAX_TIMELOCK_DELAY = 7 days;\n\n    /*--------------------------------------------------------------\n                              IMMUTABLES\n    --------------------------------------------------------------*/\n\n    /// @notice The beacon that resolves the implementation for beacon-shape wallets.\n    address public immutable BEACON;\n\n    /// @notice The implementation embedded in legacy-shape (ERC-1967, UUPS) wallets.\n    /// @dev Set to the live legacy DepositWallet implementation so {deployLegacy} reproduces the\n    ///      exact wallet addresses the pre-beacon factory deployed.\n    address public immutable LEGACY_IMPL;\n\n    /*--------------------------------------------------------------\n                              CONSTRUCTOR\n    --------------------------------------------------------------*/\n\n    /// @dev Sets the beacon and legacy implementation, then disables initializers on the\n    ///      implementation contract.\n    /// @param _beacon The beacon contract address for beacon-shape wallets.\n    /// @param _legacyImpl The legacy implementation address embedded in legacy-shape wallets.\n    constructor(address _beacon, address _legacyImpl) {\n        require(_beacon != address(0), Errors.ZeroAddress());\n        require(_legacyImpl != address(0), Errors.ZeroAddress());\n        BEACON = _beacon;\n        LEGACY_IMPL = _legacyImpl;\n        _disableInitializers();\n    }\n\n    /*--------------------------------------------------------------\n                              INITIALIZER\n    --------------------------------------------------------------*/\n\n    /// @notice Initializes the factory with an owner, admin, and timelock delay.\n    /// @param _owner The address to set as the factory owner.\n    /// @param _admin The address to grant the initial admin role.\n    /// @param _timelockDelay The initial timelock delay in seconds.\n    function initialize(address _owner, address _admin, uint256 _timelockDelay)\n        external\n        initializer\n    {\n        require(_owner != address(0), Errors.ZeroAddress());\n        require(_admin != address(0), Errors.ZeroAddress());\n        _initializeOwner(_owner);\n        _setRoles(_admin, _ROLE_0);\n        _setTimelockDelay(_timelockDelay);\n    }\n\n    /*--------------------------------------------------------------\n                               MODIFIERS\n    --------------------------------------------------------------*/\n\n    /// @dev Restricts access to addresses with the admin role (ROLE_0).\n    modifier onlyAdmin() {\n        require(hasAnyRole(msg.sender, _ROLE_0), OnlyAdmin());\n        _;\n    }\n\n    /// @dev Restricts access to addresses with the operator role (ROLE_1).\n    modifier onlyOperator() {\n        require(hasAnyRole(msg.sender, _ROLE_1), OnlyOperator());\n        _;\n    }\n\n    /// @dev Restricts access to addresses with the legacy-deployer role (ROLE_2).\n    modifier onlyLegacyDeployer() {\n        require(hasAnyRole(msg.sender, _ROLE_2), OnlyLegacyDeployer());\n        _;\n    }\n\n    /*--------------------------------------------------------------\n                                  VIEW\n    --------------------------------------------------------------*/\n\n    /// @notice Returns whether the given address has the admin role.\n    /// @param _admin The address to check.\n    /// @return True if the address is an admin.\n    function isAdmin(address _admin) external view returns (bool) {\n        return hasAnyRole(_admin, _ROLE_0);\n    }\n\n    /// @notice Returns whether the given address has the operator role.\n    /// @param _operator The address to check.\n    /// @return True if the address is an operator.\n    function isOperator(address _operator) external view returns (bool) {\n        return hasAnyRole(_operator, _ROLE_1);\n    }\n\n    /// @notice Returns whether the given address has the legacy-deployer role.\n    /// @param _legacyDeployer The address to check.\n    /// @return True if the address is a legacy deployer.\n    function isLegacyDeployer(address _legacyDeployer) external view returns (bool) {\n        return hasAnyRole(_legacyDeployer, _ROLE_2);\n    }\n\n    /// @notice Predicts the deterministic address of a wallet before deployment.\n    /// @dev Deprecated; retained for ABI compatibility. The first argument is ignored — wallets\n    ///      are now beacon proxies bound to {BEACON}. Prefer {predictWalletAddress(bytes32)}.\n    /// @param _id The unique identifier for the wallet.\n    /// @return The predicted wallet proxy address.\n    function predictWalletAddress(address, bytes32 _id) external view returns (address) {\n        return _predictWalletAddress(_id);\n    }\n\n    /// @notice Predicts the deterministic address of a beacon-proxy wallet before deployment.\n    /// @dev This returns the address derived from the beacon-proxy template. For the address of a\n    ///      legacy-shape (ERC-1967, UUPS) wallet, use {predictLegacyWalletAddress} — the two\n    ///      shapes live at different deterministic addresses because the proxy bytecode (and\n    ///      therefore the CREATE2 derivation) differs.\n    /// @param _id The unique identifier for the wallet.\n    /// @return The predicted beacon-proxy wallet address.\n    function predictWalletAddress(bytes32 _id) external view returns (address) {\n        return _predictWalletAddress(_id);\n    }\n\n    /// @notice Predicts the deterministic address of a legacy-shape (ERC-1967) wallet before\n    ///         deployment.\n    /// @dev This matches the address the pre-beacon factory assigned to a wallet with the same\n    ///      `_id` — including, on other chains, the address of the user's Polygon wallet —\n    ///      enabling cross-chain recovery at the identical address.\n    /// @param _id The unique identifier for the wallet.\n    /// @return The predicted legacy wallet address.\n    function predictLegacyWalletAddress(bytes32 _id) external view returns (address) {\n        bytes memory args = abi.encode(address(this), _id);\n\n        return LibClone.predictDeterministicAddressERC1967(\n            LEGACY_IMPL, args, keccak256(args), address(this)\n        );\n    }\n\n    /*--------------------------------------------------------------\n                             ONLY OPERATOR\n    --------------------------------------------------------------*/\n\n    /// @notice Deploys one or more beacon-shape deposit wallets with deterministic addresses.\n    /// @dev It is the operator's responsibility to ensure that each `_id` is unique.\n    ///      Duplicate IDs will cause the deployment to revert because the deterministic\n    ///      address is already occupied. Note: beacon-shape and legacy-shape wallets for the\n    ///      same `_id` live at DIFFERENT addresses (different proxy template), so they never\n    ///      collide; the operator must dedupe IDs across both shapes off-chain.\n    /// @param _owners The initial owner addresses for each wallet.\n    /// @param _ids The unique identifiers for each wallet.\n    function deploy(address[] calldata _owners, bytes32[] calldata _ids) external onlyOperator {\n        require(_owners.length == _ids.length, ArrayLengthMismatch());\n\n        // Fail closed: require both the beacon AND its resolved implementation to hold code.\n        // A beacon-proxy delegatecalls the beacon's resolved implementation, so checking only the\n        // beacon address would let a beacon resolving to a code-less implementation slip through,\n        // turning `initialize` into a silent no-op delegatecall and minting an ownerless wallet.\n        require(BEACON.code.length != 0, ImplementationNotDeployed());\n        require(IBeacon(BEACON).implementation().code.length != 0, ImplementationNotDeployed());\n\n        for (uint256 i; i < _owners.length; ++i) {\n            bytes memory args = abi.encode(address(this), _ids[i]);\n\n            address wallet =\n                LibClone.deployDeterministicERC1967BeaconProxy(BEACON, args, keccak256(args));\n\n            IDepositWallet(wallet).initialize(_owners[i]);\n\n            emit WalletDeployed(wallet, _owners[i], _ids[i], BEACON);\n        }\n    }\n\n    /// @notice Proxies batch execution to one or more wallets.\n    /// @dev Each batch is forwarded to its target wallet's `execute` function. Works for both\n    ///      wallet shapes (the `Batch` layout is identical across the legacy and current\n    ///      implementations).\n    /// @param _batches The batches to execute.\n    /// @param _signatures The corresponding signatures for each batch.\n    function proxy(Batch[] calldata _batches, bytes[] calldata _signatures) external onlyOperator {\n        require(_batches.length == _signatures.length, ArrayLengthMismatch());\n        for (uint256 i; i < _batches.length; ++i) {\n            IDepositWallet(_batches[i].wallet).execute(_batches[i], _signatures[i]);\n        }\n    }\n\n    /*--------------------------------------------------------------\n                          ONLY LEGACY DEPLOYER\n    --------------------------------------------------------------*/\n\n    /// @notice Deploys one or more legacy-shape (ERC-1967, UUPS) deposit wallets with\n    ///         deterministic addresses that match the pre-beacon factory's derivation.\n    /// @dev Restricted to the legacy-deployer role (ROLE_2), granted independently of the\n    ///      operator role. Used for ids whose legacy address has already been handed out, and for\n    ///      cross-chain recovery: a wallet deployed here lands at the same address the user's\n    ///      Polygon deposit wallet occupies. The resulting wallet runs {LEGACY_IMPL} (the V1\n    ///      implementation). See {deploy} for the ID-uniqueness and cross-shape notes.\n    /// @param _owners The initial owner addresses for each wallet.\n    /// @param _ids The unique identifiers for each wallet.\n    function deployLegacy(address[] calldata _owners, bytes32[] calldata _ids)\n        external\n        onlyLegacyDeployer\n    {\n        require(_owners.length == _ids.length, ArrayLengthMismatch());\n\n        // Fail closed: a code-less legacy implementation would mint ownerless wallets.\n        require(LEGACY_IMPL.code.length != 0, ImplementationNotDeployed());\n\n        for (uint256 i; i < _owners.length; ++i) {\n            bytes memory args = abi.encode(address(this), _ids[i]);\n\n            address wallet = LibClone.deployDeterministicERC1967(LEGACY_IMPL, args, keccak256(args));\n\n            IDepositWallet(wallet).initialize(_owners[i]);\n\n            emit WalletDeployed(wallet, _owners[i], _ids[i], LEGACY_IMPL);\n        }\n    }\n\n    /*--------------------------------------------------------------\n                               ONLY ADMIN\n    --------------------------------------------------------------*/\n\n    /// @notice Grants the operator role to an address.\n    /// @param _operator The address to grant the operator role.\n    function addOperator(address _operator) external onlyAdmin {\n        _grantRoles(_operator, _ROLE_1);\n    }\n\n    /// @notice Removes the operator role from an address.\n    /// @param _operator The address to remove the operator role from.\n    function removeOperator(address _operator) external onlyAdmin {\n        _removeRoles(_operator, _ROLE_1);\n    }\n\n    /// @notice Grants the legacy-deployer role to an address.\n    /// @param _legacyDeployer The address to grant the legacy-deployer role.\n    function addLegacyDeployer(address _legacyDeployer) external onlyAdmin {\n        _grantRoles(_legacyDeployer, _ROLE_2);\n    }\n\n    /// @notice Removes the legacy-deployer role from an address.\n    /// @param _legacyDeployer The address to remove the legacy-deployer role from.\n    function removeLegacyDeployer(address _legacyDeployer) external onlyAdmin {\n        _removeRoles(_legacyDeployer, _ROLE_2);\n    }\n\n    /// @notice Sets the timelock delay for paused wallet operations.\n    /// @param _timelockDelay The new timelock delay in seconds.\n    function setTimelockDelay(uint256 _timelockDelay) external onlyAdmin {\n        _setTimelockDelay(_timelockDelay);\n    }\n\n    /*--------------------------------------------------------------\n                               ONLY OWNER\n    --------------------------------------------------------------*/\n\n    /// @notice Grants the admin role to an address.\n    /// @param _admin The address to grant the admin role.\n    function addAdmin(address _admin) external onlyOwner {\n        _grantRoles(_admin, _ROLE_0);\n    }\n\n    /// @notice Removes the admin role from an address.\n    /// @param _admin The address to remove the admin role from.\n    function removeAdmin(address _admin) external onlyOwner {\n        _removeRoles(_admin, _ROLE_0);\n    }\n\n    /// @notice Sets the legacy slot-0 implementation pointer.\n    /// @dev Deprecated; retained for ABI compatibility. Has no effect on {deploy} (which uses\n    ///      {BEACON}) or {deployLegacy} (which uses {LEGACY_IMPL}).\n    /// @param _implementation The new default implementation address.\n    function setImplementation(address _implementation) external onlyOwner {\n        _setImplementation(_implementation);\n    }\n\n    /// @notice Authorizes an implementation address for legacy UUPS upgrades.\n    /// @dev Used during the migration window to authorize {BeaconForwarder}; will be deprecated\n    ///      after the migration window closes.\n    /// @param _implementation The implementation address to authorize.\n    function authorizeImplementation(address _implementation) external onlyOwner {\n        require(_implementation != address(0), Errors.ZeroAddress());\n        authorizedImplementation[_implementation] = true;\n\n        emit ImplementationAuthorized(_implementation);\n    }\n\n    /// @notice Removes an implementation address from the authorized set.\n    /// @dev Used during the migration window; will be deprecated after the window closes.\n    /// @param _implementation The implementation address to unauthorize.\n    function unauthorizeImplementation(address _implementation) external onlyOwner {\n        authorizedImplementation[_implementation] = false;\n\n        emit ImplementationUnauthorized(_implementation);\n    }\n\n    /*--------------------------------------------------------------\n                               INTERNAL\n    --------------------------------------------------------------*/\n\n    /// @dev Authorizes UUPS upgrades of the factory. Restricted to the owner.\n    function _authorizeUpgrade(address) internal override onlyOwner {}\n\n    /// @notice Writes the legacy slot-0 implementation pointer.\n    /// @dev Deprecated; retained for ABI compatibility. Slot 0 is no longer consulted by\n    ///      {deploy}.\n    /// @param _implementation The new default implementation address (must be authorized).\n    function _setImplementation(address _implementation) internal {\n        require(authorizedImplementation[_implementation], ImplementationNotAuthorized());\n        implementation = _implementation;\n\n        emit ImplementationSet(_implementation);\n    }\n\n    /// @notice Sets the timelock delay for paused wallet operations.\n    /// @param _timelockDelay The new timelock delay in seconds.\n    function _setTimelockDelay(uint256 _timelockDelay) internal {\n        require(_timelockDelay > 0 && _timelockDelay <= MAX_TIMELOCK_DELAY, InvalidTimelockDelay());\n        timelockDelay = _timelockDelay;\n\n        emit TimelockDelaySet(_timelockDelay);\n    }\n\n    /// @notice Computes the deterministic address of a wallet bound to {BEACON}.\n    /// @param _id The unique identifier for the wallet.\n    /// @return The predicted wallet proxy address.\n    function _predictWalletAddress(bytes32 _id) internal view returns (address) {\n        bytes memory args = abi.encode(address(this), _id);\n\n        return LibClone.predictDeterministicAddressERC1967BeaconProxy(\n            BEACON, args, keccak256(args), address(this)\n        );\n    }\n}\n"},"lib/solady/src/auth/OwnableRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/// @notice Simple single owner and multiroles authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/OwnableRoles.sol)\n///\n/// @dev Note:\n/// This implementation does NOT auto-initialize the owner to `msg.sender`.\n/// You MUST call the `_initializeOwner` in the constructor / initializer.\n///\n/// While the ownable portion follows\n/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,\n/// the nomenclature for the 2-step ownership handover may be unique to this codebase.\nabstract contract OwnableRoles is Ownable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The `user`'s roles is updated to `roles`.\n    /// Each bit of `roles` represents whether the role is set.\n    event RolesUpdated(address indexed user, uint256 indexed roles);\n\n    /// @dev `keccak256(bytes(\"RolesUpdated(address,uint256)\"))`.\n    uint256 private constant _ROLES_UPDATED_EVENT_SIGNATURE =\n        0x715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe26;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The role slot of `user` is given by:\n    /// ```\n    ///     mstore(0x00, or(shl(96, user), _ROLE_SLOT_SEED))\n    ///     let roleSlot := keccak256(0x00, 0x20)\n    /// ```\n    /// This automatically ignores the upper bits of the `user` in case\n    /// they are not clean, as well as keep the `keccak256` under 32-bytes.\n    ///\n    /// Note: This is equivalent to `uint32(bytes4(keccak256(\"_OWNER_SLOT_NOT\")))`.\n    uint256 private constant _ROLE_SLOT_SEED = 0x8b78c6d8;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Overwrite the roles directly without authorization guard.\n    function _setRoles(address user, uint256 roles) internal virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, user)\n            // Store the new value.\n            sstore(keccak256(0x0c, 0x20), roles)\n            // Emit the {RolesUpdated} event.\n            log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), roles)\n        }\n    }\n\n    /// @dev Updates the roles directly without authorization guard.\n    /// If `on` is true, each set bit of `roles` will be turned on,\n    /// otherwise, each set bit of `roles` will be turned off.\n    function _updateRoles(address user, uint256 roles, bool on) internal virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, user)\n            let roleSlot := keccak256(0x0c, 0x20)\n            // Load the current value.\n            let current := sload(roleSlot)\n            // Compute the updated roles if `on` is true.\n            let updated := or(current, roles)\n            // Compute the updated roles if `on` is false.\n            // Use `and` to compute the intersection of `current` and `roles`,\n            // `xor` it with `current` to flip the bits in the intersection.\n            if iszero(on) { updated := xor(current, and(current, roles)) }\n            // Then, store the new value.\n            sstore(roleSlot, updated)\n            // Emit the {RolesUpdated} event.\n            log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), updated)\n        }\n    }\n\n    /// @dev Grants the roles directly without authorization guard.\n    /// Each bit of `roles` represents the role to turn on.\n    function _grantRoles(address user, uint256 roles) internal virtual {\n        _updateRoles(user, roles, true);\n    }\n\n    /// @dev Removes the roles directly without authorization guard.\n    /// Each bit of `roles` represents the role to turn off.\n    function _removeRoles(address user, uint256 roles) internal virtual {\n        _updateRoles(user, roles, false);\n    }\n\n    /// @dev Throws if the sender does not have any of the `roles`.\n    function _checkRoles(uint256 roles) internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the role slot.\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, caller())\n            // Load the stored value, and if the `and` intersection\n            // of the value and `roles` is zero, revert.\n            if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {\n                mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Throws if the sender is not the owner,\n    /// and does not have any of the `roles`.\n    /// Checks for ownership first, then lazily checks for roles.\n    function _checkOwnerOrRoles(uint256 roles) internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is not the stored owner.\n            // Note: `_ROLE_SLOT_SEED` is equal to `_OWNER_SLOT_NOT`.\n            if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {\n                // Compute the role slot.\n                mstore(0x0c, _ROLE_SLOT_SEED)\n                mstore(0x00, caller())\n                // Load the stored value, and if the `and` intersection\n                // of the value and `roles` is zero, revert.\n                if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {\n                    mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n    }\n\n    /// @dev Throws if the sender does not have any of the `roles`,\n    /// and is not the owner.\n    /// Checks for roles first, then lazily checks for ownership.\n    function _checkRolesOrOwner(uint256 roles) internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the role slot.\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, caller())\n            // Load the stored value, and if the `and` intersection\n            // of the value and `roles` is zero, revert.\n            if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {\n                // If the caller is not the stored owner.\n                // Note: `_ROLE_SLOT_SEED` is equal to `_OWNER_SLOT_NOT`.\n                if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {\n                    mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n    }\n\n    /// @dev Convenience function to return a `roles` bitmap from an array of `ordinals`.\n    /// This is meant for frontends like Etherscan, and is therefore not fully optimized.\n    /// Not recommended to be called on-chain.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _rolesFromOrdinals(uint8[] memory ordinals) internal pure returns (uint256 roles) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            for { let i := shl(5, mload(ordinals)) } i { i := sub(i, 0x20) } {\n                // We don't need to mask the values of `ordinals`, as Solidity\n                // cleans dirty upper bits when storing variables into memory.\n                roles := or(shl(mload(add(ordinals, i)), 1), roles)\n            }\n        }\n    }\n\n    /// @dev Convenience function to return an array of `ordinals` from the `roles` bitmap.\n    /// This is meant for frontends like Etherscan, and is therefore not fully optimized.\n    /// Not recommended to be called on-chain.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _ordinalsFromRoles(uint256 roles) internal pure returns (uint8[] memory ordinals) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Grab the pointer to the free memory.\n            ordinals := mload(0x40)\n            let ptr := add(ordinals, 0x20)\n            let o := 0\n            // The absence of lookup tables, De Bruijn, etc., here is intentional for\n            // smaller bytecode, as this function is not meant to be called on-chain.\n            for { let t := roles } 1 {} {\n                mstore(ptr, o)\n                // `shr` 5 is equivalent to multiplying by 0x20.\n                // Push back into the ordinals array if the bit is set.\n                ptr := add(ptr, shl(5, and(t, 1)))\n                o := add(o, 1)\n                t := shr(o, roles)\n                if iszero(t) { break }\n            }\n            // Store the length of `ordinals`.\n            mstore(ordinals, shr(5, sub(ptr, add(ordinals, 0x20))))\n            // Allocate the memory.\n            mstore(0x40, ptr)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Allows the owner to grant `user` `roles`.\n    /// If the `user` already has a role, then it will be an no-op for the role.\n    function grantRoles(address user, uint256 roles) public payable virtual onlyOwner {\n        _grantRoles(user, roles);\n    }\n\n    /// @dev Allows the owner to remove `user` `roles`.\n    /// If the `user` does not have a role, then it will be an no-op for the role.\n    function revokeRoles(address user, uint256 roles) public payable virtual onlyOwner {\n        _removeRoles(user, roles);\n    }\n\n    /// @dev Allow the caller to remove their own roles.\n    /// If the caller does not have a role, then it will be an no-op for the role.\n    function renounceRoles(uint256 roles) public payable virtual {\n        _removeRoles(msg.sender, roles);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the roles of `user`.\n    function rolesOf(address user) public view virtual returns (uint256 roles) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the role slot.\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, user)\n            // Load the stored value.\n            roles := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Returns whether `user` has any of `roles`.\n    function hasAnyRole(address user, uint256 roles) public view virtual returns (bool) {\n        return rolesOf(user) & roles != 0;\n    }\n\n    /// @dev Returns whether `user` has all of `roles`.\n    function hasAllRoles(address user, uint256 roles) public view virtual returns (bool) {\n        return rolesOf(user) & roles == roles;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by an account with `roles`.\n    modifier onlyRoles(uint256 roles) virtual {\n        _checkRoles(roles);\n        _;\n    }\n\n    /// @dev Marks a function as only callable by the owner or by an account\n    /// with `roles`. Checks for ownership first, then lazily checks for roles.\n    modifier onlyOwnerOrRoles(uint256 roles) virtual {\n        _checkOwnerOrRoles(roles);\n        _;\n    }\n\n    /// @dev Marks a function as only callable by an account with `roles`\n    /// or the owner. Checks for roles first, then lazily checks for ownership.\n    modifier onlyRolesOrOwner(uint256 roles) virtual {\n        _checkRolesOrOwner(roles);\n        _;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ROLE CONSTANTS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // IYKYK\n\n    uint256 internal constant _ROLE_0 = 1 << 0;\n    uint256 internal constant _ROLE_1 = 1 << 1;\n    uint256 internal constant _ROLE_2 = 1 << 2;\n    uint256 internal constant _ROLE_3 = 1 << 3;\n    uint256 internal constant _ROLE_4 = 1 << 4;\n    uint256 internal constant _ROLE_5 = 1 << 5;\n    uint256 internal constant _ROLE_6 = 1 << 6;\n    uint256 internal constant _ROLE_7 = 1 << 7;\n    uint256 internal constant _ROLE_8 = 1 << 8;\n    uint256 internal constant _ROLE_9 = 1 << 9;\n    uint256 internal constant _ROLE_10 = 1 << 10;\n    uint256 internal constant _ROLE_11 = 1 << 11;\n    uint256 internal constant _ROLE_12 = 1 << 12;\n    uint256 internal constant _ROLE_13 = 1 << 13;\n    uint256 internal constant _ROLE_14 = 1 << 14;\n    uint256 internal constant _ROLE_15 = 1 << 15;\n    uint256 internal constant _ROLE_16 = 1 << 16;\n    uint256 internal constant _ROLE_17 = 1 << 17;\n    uint256 internal constant _ROLE_18 = 1 << 18;\n    uint256 internal constant _ROLE_19 = 1 << 19;\n    uint256 internal constant _ROLE_20 = 1 << 20;\n    uint256 internal constant _ROLE_21 = 1 << 21;\n    uint256 internal constant _ROLE_22 = 1 << 22;\n    uint256 internal constant _ROLE_23 = 1 << 23;\n    uint256 internal constant _ROLE_24 = 1 << 24;\n    uint256 internal constant _ROLE_25 = 1 << 25;\n    uint256 internal constant _ROLE_26 = 1 << 26;\n    uint256 internal constant _ROLE_27 = 1 << 27;\n    uint256 internal constant _ROLE_28 = 1 << 28;\n    uint256 internal constant _ROLE_29 = 1 << 29;\n    uint256 internal constant _ROLE_30 = 1 << 30;\n    uint256 internal constant _ROLE_31 = 1 << 31;\n    uint256 internal constant _ROLE_32 = 1 << 32;\n    uint256 internal constant _ROLE_33 = 1 << 33;\n    uint256 internal constant _ROLE_34 = 1 << 34;\n    uint256 internal constant _ROLE_35 = 1 << 35;\n    uint256 internal constant _ROLE_36 = 1 << 36;\n    uint256 internal constant _ROLE_37 = 1 << 37;\n    uint256 internal constant _ROLE_38 = 1 << 38;\n    uint256 internal constant _ROLE_39 = 1 << 39;\n    uint256 internal constant _ROLE_40 = 1 << 40;\n    uint256 internal constant _ROLE_41 = 1 << 41;\n    uint256 internal constant _ROLE_42 = 1 << 42;\n    uint256 internal constant _ROLE_43 = 1 << 43;\n    uint256 internal constant _ROLE_44 = 1 << 44;\n    uint256 internal constant _ROLE_45 = 1 << 45;\n    uint256 internal constant _ROLE_46 = 1 << 46;\n    uint256 internal constant _ROLE_47 = 1 << 47;\n    uint256 internal constant _ROLE_48 = 1 << 48;\n    uint256 internal constant _ROLE_49 = 1 << 49;\n    uint256 internal constant _ROLE_50 = 1 << 50;\n    uint256 internal constant _ROLE_51 = 1 << 51;\n    uint256 internal constant _ROLE_52 = 1 << 52;\n    uint256 internal constant _ROLE_53 = 1 << 53;\n    uint256 internal constant _ROLE_54 = 1 << 54;\n    uint256 internal constant _ROLE_55 = 1 << 55;\n    uint256 internal constant _ROLE_56 = 1 << 56;\n    uint256 internal constant _ROLE_57 = 1 << 57;\n    uint256 internal constant _ROLE_58 = 1 << 58;\n    uint256 internal constant _ROLE_59 = 1 << 59;\n    uint256 internal constant _ROLE_60 = 1 << 60;\n    uint256 internal constant _ROLE_61 = 1 << 61;\n    uint256 internal constant _ROLE_62 = 1 << 62;\n    uint256 internal constant _ROLE_63 = 1 << 63;\n    uint256 internal constant _ROLE_64 = 1 << 64;\n    uint256 internal constant _ROLE_65 = 1 << 65;\n    uint256 internal constant _ROLE_66 = 1 << 66;\n    uint256 internal constant _ROLE_67 = 1 << 67;\n    uint256 internal constant _ROLE_68 = 1 << 68;\n    uint256 internal constant _ROLE_69 = 1 << 69;\n    uint256 internal constant _ROLE_70 = 1 << 70;\n    uint256 internal constant _ROLE_71 = 1 << 71;\n    uint256 internal constant _ROLE_72 = 1 << 72;\n    uint256 internal constant _ROLE_73 = 1 << 73;\n    uint256 internal constant _ROLE_74 = 1 << 74;\n    uint256 internal constant _ROLE_75 = 1 << 75;\n    uint256 internal constant _ROLE_76 = 1 << 76;\n    uint256 internal constant _ROLE_77 = 1 << 77;\n    uint256 internal constant _ROLE_78 = 1 << 78;\n    uint256 internal constant _ROLE_79 = 1 << 79;\n    uint256 internal constant _ROLE_80 = 1 << 80;\n    uint256 internal constant _ROLE_81 = 1 << 81;\n    uint256 internal constant _ROLE_82 = 1 << 82;\n    uint256 internal constant _ROLE_83 = 1 << 83;\n    uint256 internal constant _ROLE_84 = 1 << 84;\n    uint256 internal constant _ROLE_85 = 1 << 85;\n    uint256 internal constant _ROLE_86 = 1 << 86;\n    uint256 internal constant _ROLE_87 = 1 << 87;\n    uint256 internal constant _ROLE_88 = 1 << 88;\n    uint256 internal constant _ROLE_89 = 1 << 89;\n    uint256 internal constant _ROLE_90 = 1 << 90;\n    uint256 internal constant _ROLE_91 = 1 << 91;\n    uint256 internal constant _ROLE_92 = 1 << 92;\n    uint256 internal constant _ROLE_93 = 1 << 93;\n    uint256 internal constant _ROLE_94 = 1 << 94;\n    uint256 internal constant _ROLE_95 = 1 << 95;\n    uint256 internal constant _ROLE_96 = 1 << 96;\n    uint256 internal constant _ROLE_97 = 1 << 97;\n    uint256 internal constant _ROLE_98 = 1 << 98;\n    uint256 internal constant _ROLE_99 = 1 << 99;\n    uint256 internal constant _ROLE_100 = 1 << 100;\n    uint256 internal constant _ROLE_101 = 1 << 101;\n    uint256 internal constant _ROLE_102 = 1 << 102;\n    uint256 internal constant _ROLE_103 = 1 << 103;\n    uint256 internal constant _ROLE_104 = 1 << 104;\n    uint256 internal constant _ROLE_105 = 1 << 105;\n    uint256 internal constant _ROLE_106 = 1 << 106;\n    uint256 internal constant _ROLE_107 = 1 << 107;\n    uint256 internal constant _ROLE_108 = 1 << 108;\n    uint256 internal constant _ROLE_109 = 1 << 109;\n    uint256 internal constant _ROLE_110 = 1 << 110;\n    uint256 internal constant _ROLE_111 = 1 << 111;\n    uint256 internal constant _ROLE_112 = 1 << 112;\n    uint256 internal constant _ROLE_113 = 1 << 113;\n    uint256 internal constant _ROLE_114 = 1 << 114;\n    uint256 internal constant _ROLE_115 = 1 << 115;\n    uint256 internal constant _ROLE_116 = 1 << 116;\n    uint256 internal constant _ROLE_117 = 1 << 117;\n    uint256 internal constant _ROLE_118 = 1 << 118;\n    uint256 internal constant _ROLE_119 = 1 << 119;\n    uint256 internal constant _ROLE_120 = 1 << 120;\n    uint256 internal constant _ROLE_121 = 1 << 121;\n    uint256 internal constant _ROLE_122 = 1 << 122;\n    uint256 internal constant _ROLE_123 = 1 << 123;\n    uint256 internal constant _ROLE_124 = 1 << 124;\n    uint256 internal constant _ROLE_125 = 1 << 125;\n    uint256 internal constant _ROLE_126 = 1 << 126;\n    uint256 internal constant _ROLE_127 = 1 << 127;\n    uint256 internal constant _ROLE_128 = 1 << 128;\n    uint256 internal constant _ROLE_129 = 1 << 129;\n    uint256 internal constant _ROLE_130 = 1 << 130;\n    uint256 internal constant _ROLE_131 = 1 << 131;\n    uint256 internal constant _ROLE_132 = 1 << 132;\n    uint256 internal constant _ROLE_133 = 1 << 133;\n    uint256 internal constant _ROLE_134 = 1 << 134;\n    uint256 internal constant _ROLE_135 = 1 << 135;\n    uint256 internal constant _ROLE_136 = 1 << 136;\n    uint256 internal constant _ROLE_137 = 1 << 137;\n    uint256 internal constant _ROLE_138 = 1 << 138;\n    uint256 internal constant _ROLE_139 = 1 << 139;\n    uint256 internal constant _ROLE_140 = 1 << 140;\n    uint256 internal constant _ROLE_141 = 1 << 141;\n    uint256 internal constant _ROLE_142 = 1 << 142;\n    uint256 internal constant _ROLE_143 = 1 << 143;\n    uint256 internal constant _ROLE_144 = 1 << 144;\n    uint256 internal constant _ROLE_145 = 1 << 145;\n    uint256 internal constant _ROLE_146 = 1 << 146;\n    uint256 internal constant _ROLE_147 = 1 << 147;\n    uint256 internal constant _ROLE_148 = 1 << 148;\n    uint256 internal constant _ROLE_149 = 1 << 149;\n    uint256 internal constant _ROLE_150 = 1 << 150;\n    uint256 internal constant _ROLE_151 = 1 << 151;\n    uint256 internal constant _ROLE_152 = 1 << 152;\n    uint256 internal constant _ROLE_153 = 1 << 153;\n    uint256 internal constant _ROLE_154 = 1 << 154;\n    uint256 internal constant _ROLE_155 = 1 << 155;\n    uint256 internal constant _ROLE_156 = 1 << 156;\n    uint256 internal constant _ROLE_157 = 1 << 157;\n    uint256 internal constant _ROLE_158 = 1 << 158;\n    uint256 internal constant _ROLE_159 = 1 << 159;\n    uint256 internal constant _ROLE_160 = 1 << 160;\n    uint256 internal constant _ROLE_161 = 1 << 161;\n    uint256 internal constant _ROLE_162 = 1 << 162;\n    uint256 internal constant _ROLE_163 = 1 << 163;\n    uint256 internal constant _ROLE_164 = 1 << 164;\n    uint256 internal constant _ROLE_165 = 1 << 165;\n    uint256 internal constant _ROLE_166 = 1 << 166;\n    uint256 internal constant _ROLE_167 = 1 << 167;\n    uint256 internal constant _ROLE_168 = 1 << 168;\n    uint256 internal constant _ROLE_169 = 1 << 169;\n    uint256 internal constant _ROLE_170 = 1 << 170;\n    uint256 internal constant _ROLE_171 = 1 << 171;\n    uint256 internal constant _ROLE_172 = 1 << 172;\n    uint256 internal constant _ROLE_173 = 1 << 173;\n    uint256 internal constant _ROLE_174 = 1 << 174;\n    uint256 internal constant _ROLE_175 = 1 << 175;\n    uint256 internal constant _ROLE_176 = 1 << 176;\n    uint256 internal constant _ROLE_177 = 1 << 177;\n    uint256 internal constant _ROLE_178 = 1 << 178;\n    uint256 internal constant _ROLE_179 = 1 << 179;\n    uint256 internal constant _ROLE_180 = 1 << 180;\n    uint256 internal constant _ROLE_181 = 1 << 181;\n    uint256 internal constant _ROLE_182 = 1 << 182;\n    uint256 internal constant _ROLE_183 = 1 << 183;\n    uint256 internal constant _ROLE_184 = 1 << 184;\n    uint256 internal constant _ROLE_185 = 1 << 185;\n    uint256 internal constant _ROLE_186 = 1 << 186;\n    uint256 internal constant _ROLE_187 = 1 << 187;\n    uint256 internal constant _ROLE_188 = 1 << 188;\n    uint256 internal constant _ROLE_189 = 1 << 189;\n    uint256 internal constant _ROLE_190 = 1 << 190;\n    uint256 internal constant _ROLE_191 = 1 << 191;\n    uint256 internal constant _ROLE_192 = 1 << 192;\n    uint256 internal constant _ROLE_193 = 1 << 193;\n    uint256 internal constant _ROLE_194 = 1 << 194;\n    uint256 internal constant _ROLE_195 = 1 << 195;\n    uint256 internal constant _ROLE_196 = 1 << 196;\n    uint256 internal constant _ROLE_197 = 1 << 197;\n    uint256 internal constant _ROLE_198 = 1 << 198;\n    uint256 internal constant _ROLE_199 = 1 << 199;\n    uint256 internal constant _ROLE_200 = 1 << 200;\n    uint256 internal constant _ROLE_201 = 1 << 201;\n    uint256 internal constant _ROLE_202 = 1 << 202;\n    uint256 internal constant _ROLE_203 = 1 << 203;\n    uint256 internal constant _ROLE_204 = 1 << 204;\n    uint256 internal constant _ROLE_205 = 1 << 205;\n    uint256 internal constant _ROLE_206 = 1 << 206;\n    uint256 internal constant _ROLE_207 = 1 << 207;\n    uint256 internal constant _ROLE_208 = 1 << 208;\n    uint256 internal constant _ROLE_209 = 1 << 209;\n    uint256 internal constant _ROLE_210 = 1 << 210;\n    uint256 internal constant _ROLE_211 = 1 << 211;\n    uint256 internal constant _ROLE_212 = 1 << 212;\n    uint256 internal constant _ROLE_213 = 1 << 213;\n    uint256 internal constant _ROLE_214 = 1 << 214;\n    uint256 internal constant _ROLE_215 = 1 << 215;\n    uint256 internal constant _ROLE_216 = 1 << 216;\n    uint256 internal constant _ROLE_217 = 1 << 217;\n    uint256 internal constant _ROLE_218 = 1 << 218;\n    uint256 internal constant _ROLE_219 = 1 << 219;\n    uint256 internal constant _ROLE_220 = 1 << 220;\n    uint256 internal constant _ROLE_221 = 1 << 221;\n    uint256 internal constant _ROLE_222 = 1 << 222;\n    uint256 internal constant _ROLE_223 = 1 << 223;\n    uint256 internal constant _ROLE_224 = 1 << 224;\n    uint256 internal constant _ROLE_225 = 1 << 225;\n    uint256 internal constant _ROLE_226 = 1 << 226;\n    uint256 internal constant _ROLE_227 = 1 << 227;\n    uint256 internal constant _ROLE_228 = 1 << 228;\n    uint256 internal constant _ROLE_229 = 1 << 229;\n    uint256 internal constant _ROLE_230 = 1 << 230;\n    uint256 internal constant _ROLE_231 = 1 << 231;\n    uint256 internal constant _ROLE_232 = 1 << 232;\n    uint256 internal constant _ROLE_233 = 1 << 233;\n    uint256 internal constant _ROLE_234 = 1 << 234;\n    uint256 internal constant _ROLE_235 = 1 << 235;\n    uint256 internal constant _ROLE_236 = 1 << 236;\n    uint256 internal constant _ROLE_237 = 1 << 237;\n    uint256 internal constant _ROLE_238 = 1 << 238;\n    uint256 internal constant _ROLE_239 = 1 << 239;\n    uint256 internal constant _ROLE_240 = 1 << 240;\n    uint256 internal constant _ROLE_241 = 1 << 241;\n    uint256 internal constant _ROLE_242 = 1 << 242;\n    uint256 internal constant _ROLE_243 = 1 << 243;\n    uint256 internal constant _ROLE_244 = 1 << 244;\n    uint256 internal constant _ROLE_245 = 1 << 245;\n    uint256 internal constant _ROLE_246 = 1 << 246;\n    uint256 internal constant _ROLE_247 = 1 << 247;\n    uint256 internal constant _ROLE_248 = 1 << 248;\n    uint256 internal constant _ROLE_249 = 1 << 249;\n    uint256 internal constant _ROLE_250 = 1 << 250;\n    uint256 internal constant _ROLE_251 = 1 << 251;\n    uint256 internal constant _ROLE_252 = 1 << 252;\n    uint256 internal constant _ROLE_253 = 1 << 253;\n    uint256 internal constant _ROLE_254 = 1 << 254;\n    uint256 internal constant _ROLE_255 = 1 << 255;\n}\n"},"lib/solady/src/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Initializable mixin for the upgradeable contracts.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Initializable.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/proxy/utils/Initializable.sol)\nabstract contract Initializable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The contract is already initialized.\n    error InvalidInitialization();\n\n    /// @dev The contract is not initializing.\n    error NotInitializing();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Triggered when the contract has been initialized.\n    event Initialized(uint64 version);\n\n    /// @dev `keccak256(bytes(\"Initialized(uint64)\"))`.\n    bytes32 private constant _INITIALIZED_EVENT_SIGNATURE =\n        0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The default initializable slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_INITIALIZABLE_SLOT\")))))`.\n    ///\n    /// Bits Layout:\n    /// - [0]     `initializing`\n    /// - [1..64] `initializedVersion`\n    bytes32 private constant _INITIALIZABLE_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffbf601132;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                        CONSTRUCTOR                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    constructor() {\n        // Construction time check to ensure that `_initializableSlot()` is not\n        // overridden to zero. Will be optimized away if there is no revert.\n        require(_initializableSlot() != bytes32(0));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         OPERATIONS                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return a non-zero custom storage slot if required.\n    function _initializableSlot() internal pure virtual returns (bytes32) {\n        return _INITIALIZABLE_SLOT;\n    }\n\n    /// @dev Guards an initializer function so that it can be invoked at most once.\n    ///\n    /// You can guard a function with `onlyInitializing` such that it can be called\n    /// through a function guarded with `initializer`.\n    ///\n    /// This is similar to `reinitializer(1)`, except that in the context of a constructor,\n    /// an `initializer` guarded function can be invoked multiple times.\n    /// This can be useful during testing and is not expected to be used in production.\n    ///\n    /// Emits an {Initialized} event.\n    modifier initializer() virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let i := sload(s)\n            // Set `initializing` to 1, `initializedVersion` to 1.\n            sstore(s, 3)\n            // If `!(initializing == 0 && initializedVersion == 0)`.\n            if i {\n                // If `!(address(this).code.length == 0 && initializedVersion == 1)`.\n                if iszero(lt(extcodesize(address()), eq(shr(1, i), 1))) {\n                    mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                    revert(0x1c, 0x04)\n                }\n                s := shl(shl(255, i), s) // Skip initializing if `initializing == 1`.\n            }\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            if s {\n                // Set `initializing` to 0, `initializedVersion` to 1.\n                sstore(s, 2)\n                // Emit the {Initialized} event.\n                mstore(0x20, 1)\n                log1(0x20, 0x20, _INITIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Guards a reinitializer function so that it can be invoked at most once.\n    ///\n    /// You can guard a function with `onlyInitializing` such that it can be called\n    /// through a function guarded with `reinitializer`.\n    ///\n    /// Emits an {Initialized} event.\n    modifier reinitializer(uint64 version) virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Clean upper bits, and shift left by 1 to make space for the initializing bit.\n            version := shl(1, and(version, 0xffffffffffffffff))\n            let i := sload(s)\n            // If `initializing == 1 || initializedVersion >= version`.\n            if iszero(lt(and(i, 1), lt(i, version))) {\n                mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                revert(0x1c, 0x04)\n            }\n            // Set `initializing` to 1, `initializedVersion` to `version`.\n            sstore(s, or(1, version))\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Set `initializing` to 0, `initializedVersion` to `version`.\n            sstore(s, version)\n            // Emit the {Initialized} event.\n            mstore(0x20, shr(1, version))\n            log1(0x20, 0x20, _INITIALIZED_EVENT_SIGNATURE)\n        }\n    }\n\n    /// @dev Guards a function such that it can only be called in the scope\n    /// of a function guarded with `initializer` or `reinitializer`.\n    modifier onlyInitializing() virtual {\n        _checkInitializing();\n        _;\n    }\n\n    /// @dev Reverts if the contract is not initializing.\n    function _checkInitializing() internal view virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(and(1, sload(s))) {\n                mstore(0x00, 0xd7e6bcf8) // `NotInitializing()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Locks any future initializations by setting the initialized version to `2**64 - 1`.\n    ///\n    /// Calling this in the constructor will prevent the contract from being initialized\n    /// or reinitialized. It is recommended to use this to lock implementation contracts\n    /// that are designed to be called through proxies.\n    ///\n    /// Emits an {Initialized} event the first time it is successfully called.\n    function _disableInitializers() internal virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let i := sload(s)\n            if and(i, 1) {\n                mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                revert(0x1c, 0x04)\n            }\n            let uint64max := 0xffffffffffffffff\n            if iszero(eq(shr(1, i), uint64max)) {\n                // Set `initializing` to 0, `initializedVersion` to `2**64 - 1`.\n                sstore(s, shl(1, uint64max))\n                // Emit the {Initialized} event.\n                mstore(0x20, uint64max)\n                log1(0x20, 0x20, _INITIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Returns the highest version that has been initialized.\n    function _getInitializedVersion() internal view virtual returns (uint64 version) {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            version := shr(1, sload(s))\n        }\n    }\n\n    /// @dev Returns whether the contract is currently initializing.\n    function _isInitializing() internal view virtual returns (bool result) {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := and(1, sload(s))\n        }\n    }\n}\n"},"lib/solady/src/utils/LibClone.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Minimal proxy library.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibClone.sol)\n/// @author Minimal proxy by 0age (https://github.com/0age)\n/// @author Clones with immutable args by wighawag, zefram.eth, Saw-mon & Natalie\n/// (https://github.com/Saw-mon-and-Natalie/clones-with-immutable-args)\n/// @author Minimal ERC1967 proxy by jtriley-eth (https://github.com/jtriley-eth/minimum-viable-proxy)\n///\n/// @dev Minimal proxy:\n/// Although the sw0nt pattern saves 5 gas over the ERC1167 pattern during runtime,\n/// it is not supported out-of-the-box on Etherscan. Hence, we choose to use the 0age pattern,\n/// which saves 4 gas over the ERC1167 pattern during runtime, and has the smallest bytecode.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal proxy (PUSH0 variant):\n/// This is a new minimal proxy that uses the PUSH0 opcode introduced during Shanghai.\n/// It is optimized first for minimal runtime gas, then for minimal bytecode.\n/// The PUSH0 clone functions are intentionally postfixed with a jarring \"_PUSH0\" as\n/// many EVM chains may not support the PUSH0 opcode in the early months after Shanghai.\n/// Please use with caution.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Clones with immutable args (CWIA):\n/// The implementation of CWIA here does NOT append the immutable args into the calldata\n/// passed into delegatecall. It is simply an ERC1167 minimal proxy with the immutable arguments\n/// appended to the back of the runtime bytecode.\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n///\n/// @dev Minimal ERC1967 proxy:\n/// A minimal ERC1967 proxy, intended to be upgraded with UUPS.\n/// This is NOT the same as ERC1967Factory's transparent proxy, which includes admin logic.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal ERC1967 proxy with immutable args:\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n/// - Automatically verified on Etherscan.\n///\n/// @dev ERC1967I proxy:\n/// A variant of the minimal ERC1967 proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// `implementation` address. The returned implementation is guaranteed to be valid if the\n/// keccak256 of the proxy's code is equal to `ERC1967I_CODE_HASH`.\n///\n/// @dev ERC1967I proxy with immutable args:\n/// A variant of the minimal ERC1967 proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n///\n/// @dev Minimal ERC1967 beacon proxy:\n/// A minimal beacon proxy, intended to be upgraded with an upgradable beacon.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal ERC1967 beacon proxy with immutable args:\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n/// - Automatically verified on Etherscan.\n///\n/// @dev ERC1967I beacon proxy:\n/// A variant of the minimal ERC1967 beacon proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// `implementation` address. The returned implementation is guaranteed to be valid if the\n/// keccak256 of the proxy's code is equal to `ERC1967I_CODE_HASH`.\n///\n/// @dev ERC1967I proxy with immutable args:\n/// A variant of the minimal ERC1967 beacon proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// - Uses the identity precompile (0x4) to copy args during deployment.\nlibrary LibClone {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The keccak256 of deployed code for the clone proxy,\n    /// with the implementation set to `address(0)`.\n    bytes32 internal constant CLONE_CODE_HASH =\n        0x48db2cfdb2853fce0b464f1f93a1996469459df3ab6c812106074c4106a1eb1f;\n\n    /// @dev The keccak256 of deployed code for the PUSH0 proxy,\n    /// with the implementation set to `address(0)`.\n    bytes32 internal constant PUSH0_CLONE_CODE_HASH =\n        0x67bc6bde1b84d66e267c718ba44cf3928a615d29885537955cb43d44b3e789dc;\n\n    /// @dev The keccak256 of deployed code for the ERC-1167 CWIA proxy,\n    /// with the implementation set to `address(0)`.\n    bytes32 internal constant CWIA_CODE_HASH =\n        0x3cf92464268225a4513da40a34d967354684c32cd0edd67b5f668dfe3550e940;\n\n    /// @dev The keccak256 of the deployed code for the ERC1967 proxy.\n    bytes32 internal constant ERC1967_CODE_HASH =\n        0xaaa52c8cc8a0e3fd27ce756cc6b4e70c51423e9b597b11f32d3e49f8b1fc890d;\n\n    /// @dev The keccak256 of the deployed code for the ERC1967I proxy.\n    bytes32 internal constant ERC1967I_CODE_HASH =\n        0xce700223c0d4cea4583409accfc45adac4a093b3519998a9cbbe1504dadba6f7;\n\n    /// @dev The keccak256 of the deployed code for the ERC1967 beacon proxy.\n    bytes32 internal constant ERC1967_BEACON_PROXY_CODE_HASH =\n        0x14044459af17bc4f0f5aa2f658cb692add77d1302c29fe2aebab005eea9d1162;\n\n    /// @dev The keccak256 of the deployed code for the ERC1967 beacon proxy.\n    bytes32 internal constant ERC1967I_BEACON_PROXY_CODE_HASH =\n        0xf8c46d2793d5aa984eb827aeaba4b63aedcab80119212fce827309788735519a;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Unable to deploy the clone.\n    error DeploymentFailed();\n\n    /// @dev The salt must start with either the zero address or `by`.\n    error SaltDoesNotStartWith();\n\n    /// @dev The ETH transfer has failed.\n    error ETHTransferFailed();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  MINIMAL PROXY OPERATIONS                  */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a clone of `implementation`.\n    function clone(address implementation) internal returns (address instance) {\n        instance = clone(0, implementation);\n    }\n\n    /// @dev Deploys a clone of `implementation`.\n    /// Deposits `value` ETH during deployment.\n    function clone(uint256 value, address implementation) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * --------------------------------------------------------------------------+\n             * CREATION (9 bytes)                                                        |\n             * --------------------------------------------------------------------------|\n             * Opcode     | Mnemonic          | Stack     | Memory                       |\n             * --------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize     | r         |                              |\n             * 3d         | RETURNDATASIZE    | 0 r       |                              |\n             * 81         | DUP2              | r 0 r     |                              |\n             * 60 offset  | PUSH1 offset      | o r 0 r   |                              |\n             * 3d         | RETURNDATASIZE    | 0 o r 0 r |                              |\n             * 39         | CODECOPY          | 0 r       | [0..runSize): runtime code   |\n             * f3         | RETURN            |           | [0..runSize): runtime code   |\n             * --------------------------------------------------------------------------|\n             * RUNTIME (44 bytes)                                                        |\n             * --------------------------------------------------------------------------|\n             * Opcode  | Mnemonic       | Stack                  | Memory                |\n             * --------------------------------------------------------------------------|\n             *                                                                           |\n             * ::: keep some values in stack ::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d      | RETURNDATASIZE | 0                      |                       |\n             * 3d      | RETURNDATASIZE | 0 0                    |                       |\n             * 3d      | RETURNDATASIZE | 0 0 0                  |                       |\n             * 3d      | RETURNDATASIZE | 0 0 0 0                |                       |\n             *                                                                           |\n             * ::: copy calldata to memory ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36      | CALLDATASIZE   | cds 0 0 0 0            |                       |\n             * 3d      | RETURNDATASIZE | 0 cds 0 0 0 0          |                       |\n             * 3d      | RETURNDATASIZE | 0 0 cds 0 0 0 0        |                       |\n             * 37      | CALLDATACOPY   | 0 0 0 0                | [0..cds): calldata    |\n             *                                                                           |\n             * ::: delegate call to the implementation contract :::::::::::::::::::::::: |\n             * 36      | CALLDATASIZE   | cds 0 0 0 0            | [0..cds): calldata    |\n             * 3d      | RETURNDATASIZE | 0 cds 0 0 0 0          | [0..cds): calldata    |\n             * 73 addr | PUSH20 addr    | addr 0 cds 0 0 0 0     | [0..cds): calldata    |\n             * 5a      | GAS            | gas addr 0 cds 0 0 0 0 | [0..cds): calldata    |\n             * f4      | DELEGATECALL   | success 0 0            | [0..cds): calldata    |\n             *                                                                           |\n             * ::: copy return data to memory :::::::::::::::::::::::::::::::::::::::::: |\n             * 3d      | RETURNDATASIZE | rds success 0 0        | [0..cds): calldata    |\n             * 3d      | RETURNDATASIZE | rds rds success 0 0    | [0..cds): calldata    |\n             * 93      | SWAP4          | 0 rds success 0 rds    | [0..cds): calldata    |\n             * 80      | DUP1           | 0 0 rds success 0 rds  | [0..cds): calldata    |\n             * 3e      | RETURNDATACOPY | success 0 rds          | [0..rds): returndata  |\n             *                                                                           |\n             * 60 0x2a | PUSH1 0x2a     | 0x2a success 0 rds     | [0..rds): returndata  |\n             * 57      | JUMPI          | 0 rds                  | [0..rds): returndata  |\n             *                                                                           |\n             * ::: revert :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * fd      | REVERT         |                        | [0..rds): returndata  |\n             *                                                                           |\n             * ::: return :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b      | JUMPDEST       | 0 rds                  | [0..rds): returndata  |\n             * f3      | RETURN         |                        | [0..rds): returndata  |\n             * --------------------------------------------------------------------------+\n             */\n            mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n            mstore(0x14, implementation)\n            mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n            instance := create(value, 0x0c, 0x35)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation` with `salt`.\n    function cloneDeterministic(address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = cloneDeterministic(0, implementation, salt);\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation` with `salt`.\n    /// Deposits `value` ETH during deployment.\n    function cloneDeterministic(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n            mstore(0x14, implementation)\n            mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n            instance := create2(value, 0x0c, 0x35, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the clone of `implementation`.\n    function initCode(address implementation) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x40), 0x5af43d3d93803e602a57fd5bf30000000000000000000000)\n            mstore(add(c, 0x28), implementation)\n            mstore(add(c, 0x14), 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n            mstore(c, 0x35) // Store the length.\n            mstore(0x40, add(c, 0x60)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the clone of `implementation`.\n    function initCodeHash(address implementation) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n            mstore(0x14, implementation)\n            mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n            hash := keccak256(0x0c, 0x35)\n            mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the address of the clone of `implementation`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddress(address implementation, bytes32 salt, address deployer)\n        internal\n        pure\n        returns (address predicted)\n    {\n        bytes32 hash = initCodeHash(implementation);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*          MINIMAL PROXY OPERATIONS (PUSH0 VARIANT)          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a PUSH0 clone of `implementation`.\n    function clone_PUSH0(address implementation) internal returns (address instance) {\n        instance = clone_PUSH0(0, implementation);\n    }\n\n    /// @dev Deploys a PUSH0 clone of `implementation`.\n    /// Deposits `value` ETH during deployment.\n    function clone_PUSH0(uint256 value, address implementation)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * --------------------------------------------------------------------------+\n             * CREATION (9 bytes)                                                        |\n             * --------------------------------------------------------------------------|\n             * Opcode     | Mnemonic          | Stack     | Memory                       |\n             * --------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize     | r         |                              |\n             * 5f         | PUSH0             | 0 r       |                              |\n             * 81         | DUP2              | r 0 r     |                              |\n             * 60 offset  | PUSH1 offset      | o r 0 r   |                              |\n             * 5f         | PUSH0             | 0 o r 0 r |                              |\n             * 39         | CODECOPY          | 0 r       | [0..runSize): runtime code   |\n             * f3         | RETURN            |           | [0..runSize): runtime code   |\n             * --------------------------------------------------------------------------|\n             * RUNTIME (45 bytes)                                                        |\n             * --------------------------------------------------------------------------|\n             * Opcode  | Mnemonic       | Stack                  | Memory                |\n             * --------------------------------------------------------------------------|\n             *                                                                           |\n             * ::: keep some values in stack ::::::::::::::::::::::::::::::::::::::::::: |\n             * 5f      | PUSH0          | 0                      |                       |\n             * 5f      | PUSH0          | 0 0                    |                       |\n             *                                                                           |\n             * ::: copy calldata to memory ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36      | CALLDATASIZE   | cds 0 0                |                       |\n             * 5f      | PUSH0          | 0 cds 0 0              |                       |\n             * 5f      | PUSH0          | 0 0 cds 0 0            |                       |\n             * 37      | CALLDATACOPY   | 0 0                    | [0..cds): calldata    |\n             *                                                                           |\n             * ::: delegate call to the implementation contract :::::::::::::::::::::::: |\n             * 36      | CALLDATASIZE   | cds 0 0                | [0..cds): calldata    |\n             * 5f      | PUSH0          | 0 cds 0 0              | [0..cds): calldata    |\n             * 73 addr | PUSH20 addr    | addr 0 cds 0 0         | [0..cds): calldata    |\n             * 5a      | GAS            | gas addr 0 cds 0 0     | [0..cds): calldata    |\n             * f4      | DELEGATECALL   | success                | [0..cds): calldata    |\n             *                                                                           |\n             * ::: copy return data to memory :::::::::::::::::::::::::::::::::::::::::: |\n             * 3d      | RETURNDATASIZE | rds success            | [0..cds): calldata    |\n             * 5f      | PUSH0          | 0 rds success          | [0..cds): calldata    |\n             * 5f      | PUSH0          | 0 0 rds success        | [0..cds): calldata    |\n             * 3e      | RETURNDATACOPY | success                | [0..rds): returndata  |\n             *                                                                           |\n             * 60 0x29 | PUSH1 0x29     | 0x29 success           | [0..rds): returndata  |\n             * 57      | JUMPI          |                        | [0..rds): returndata  |\n             *                                                                           |\n             * ::: revert :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d      | RETURNDATASIZE | rds                    | [0..rds): returndata  |\n             * 5f      | PUSH0          | 0 rds                  | [0..rds): returndata  |\n             * fd      | REVERT         |                        | [0..rds): returndata  |\n             *                                                                           |\n             * ::: return :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b      | JUMPDEST       |                        | [0..rds): returndata  |\n             * 3d      | RETURNDATASIZE | rds                    | [0..rds): returndata  |\n             * 5f      | PUSH0          | 0 rds                  | [0..rds): returndata  |\n             * f3      | RETURN         |                        | [0..rds): returndata  |\n             * --------------------------------------------------------------------------+\n             */\n            mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n            mstore(0x14, implementation) // 20\n            mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n            instance := create(value, 0x0e, 0x36)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Deploys a deterministic PUSH0 clone of `implementation` with `salt`.\n    function cloneDeterministic_PUSH0(address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = cloneDeterministic_PUSH0(0, implementation, salt);\n    }\n\n    /// @dev Deploys a deterministic PUSH0 clone of `implementation` with `salt`.\n    /// Deposits `value` ETH during deployment.\n    function cloneDeterministic_PUSH0(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n            mstore(0x14, implementation) // 20\n            mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n            instance := create2(value, 0x0e, 0x36, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the PUSH0 clone of `implementation`.\n    function initCode_PUSH0(address implementation) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x40), 0x5af43d5f5f3e6029573d5ffd5b3d5ff300000000000000000000) // 16\n            mstore(add(c, 0x26), implementation) // 20\n            mstore(add(c, 0x12), 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n            mstore(c, 0x36) // Store the length.\n            mstore(0x40, add(c, 0x60)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the PUSH0 clone of `implementation`.\n    function initCodeHash_PUSH0(address implementation) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n            mstore(0x14, implementation) // 20\n            mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n            hash := keccak256(0x0e, 0x36)\n            mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the address of the PUSH0 clone of `implementation`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddress_PUSH0(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHash_PUSH0(implementation);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*           CLONES WITH IMMUTABLE ARGS OPERATIONS            */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a clone of `implementation` with immutable arguments encoded in `args`.\n    function clone(address implementation, bytes memory args) internal returns (address instance) {\n        instance = clone(0, implementation, args);\n    }\n\n    /// @dev Deploys a clone of `implementation` with immutable arguments encoded in `args`.\n    /// Deposits `value` ETH during deployment.\n    function clone(uint256 value, address implementation, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------+\n             * CREATION (10 bytes)                                                        |\n             * ---------------------------------------------------------------------------|\n             * Opcode     | Mnemonic          | Stack     | Memory                        |\n             * ---------------------------------------------------------------------------|\n             * 61 runSize | PUSH2 runSize     | r         |                               |\n             * 3d         | RETURNDATASIZE    | 0 r       |                               |\n             * 81         | DUP2              | r 0 r     |                               |\n             * 60 offset  | PUSH1 offset      | o r 0 r   |                               |\n             * 3d         | RETURNDATASIZE    | 0 o r 0 r |                               |\n             * 39         | CODECOPY          | 0 r       | [0..runSize): runtime code    |\n             * f3         | RETURN            |           | [0..runSize): runtime code    |\n             * ---------------------------------------------------------------------------|\n             * RUNTIME (45 bytes + extraLength)                                           |\n             * ---------------------------------------------------------------------------|\n             * Opcode   | Mnemonic       | Stack                  | Memory                |\n             * ---------------------------------------------------------------------------|\n             *                                                                            |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36       | CALLDATASIZE   | cds                    |                       |\n             * 3d       | RETURNDATASIZE | 0 cds                  |                       |\n             * 3d       | RETURNDATASIZE | 0 0 cds                |                       |\n             * 37       | CALLDATACOPY   |                        | [0..cds): calldata    |\n             *                                                                            |\n             * ::: delegate call to the implementation contract ::::::::::::::::::::::::: |\n             * 3d       | RETURNDATASIZE | 0                      | [0..cds): calldata    |\n             * 3d       | RETURNDATASIZE | 0 0                    | [0..cds): calldata    |\n             * 3d       | RETURNDATASIZE | 0 0 0                  | [0..cds): calldata    |\n             * 36       | CALLDATASIZE   | cds 0 0 0              | [0..cds): calldata    |\n             * 3d       | RETURNDATASIZE | 0 cds 0 0 0 0          | [0..cds): calldata    |\n             * 73 addr  | PUSH20 addr    | addr 0 cds 0 0 0 0     | [0..cds): calldata    |\n             * 5a       | GAS            | gas addr 0 cds 0 0 0 0 | [0..cds): calldata    |\n             * f4       | DELEGATECALL   | success 0 0            | [0..cds): calldata    |\n             *                                                                            |\n             * ::: copy return data to memory ::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d       | RETURNDATASIZE | rds success 0          | [0..cds): calldata    |\n             * 82       | DUP3           | 0 rds success 0         | [0..cds): calldata   |\n             * 80       | DUP1           | 0 0 rds success 0      | [0..cds): calldata    |\n             * 3e       | RETURNDATACOPY | success 0              | [0..rds): returndata  |\n             * 90       | SWAP1          | 0 success              | [0..rds): returndata  |\n             * 3d       | RETURNDATASIZE | rds 0 success          | [0..rds): returndata  |\n             * 91       | SWAP2          | success 0 rds          | [0..rds): returndata  |\n             *                                                                            |\n             * 60 0x2b  | PUSH1 0x2b     | 0x2b success 0 rds     | [0..rds): returndata  |\n             * 57       | JUMPI          | 0 rds                  | [0..rds): returndata  |\n             *                                                                            |\n             * ::: revert ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * fd       | REVERT         |                        | [0..rds): returndata  |\n             *                                                                            |\n             * ::: return ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b       | JUMPDEST       | 0 rds                  | [0..rds): returndata  |\n             * f3       | RETURN         |                        | [0..rds): returndata  |\n             * ---------------------------------------------------------------------------+\n             */\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n            mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            instance := create(value, add(m, add(0x0b, lt(n, 0xffd3))), add(n, 0x37))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation`\n    /// with immutable arguments encoded in `args` and `salt`.\n    function cloneDeterministic(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = cloneDeterministic(0, implementation, args, salt);\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation`\n    /// with immutable arguments encoded in `args` and `salt`.\n    function cloneDeterministic(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n            mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            instance := create2(value, add(m, add(0x0b, lt(n, 0xffd3))), add(n, 0x37), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation`\n    /// with immutable arguments encoded in `args` and `salt`.\n    /// This method does not revert if the clone has already been deployed.\n    function createDeterministicClone(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicClone(0, implementation, args, salt);\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation`\n    /// with immutable arguments encoded in `args` and `salt`.\n    /// This method does not revert if the clone has already been deployed.\n    function createDeterministicClone(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n            mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(m, 0x14), implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            // forgefmt: disable-next-item\n            mstore(add(m, gt(n, 0xffd2)), add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(add(m, 0x0c), add(n, 0x37)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, add(m, 0x0c), add(n, 0x37), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the clone of `implementation`\n    /// using immutable arguments encoded in `args`.\n    function initCode(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffd2))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x57), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x37), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(c, 0x28), implementation)\n            mstore(add(c, 0x14), add(0x61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            mstore(c, add(0x37, n)) // Store the length.\n            mstore(add(c, add(n, 0x57)), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(c, add(n, 0x77))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the clone of `implementation`\n    /// using immutable arguments encoded in `args`.\n    function initCodeHash(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffd2))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x43), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0x61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            hash := keccak256(add(m, 0x0c), add(n, 0x37))\n        }\n    }\n\n    /// @dev Returns the address of the clone of\n    /// `implementation` using immutable arguments encoded in `args`, with `salt`, by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddress(\n        address implementation,\n        bytes memory data,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHash(implementation, data);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnClone(instance, 0, 2 ** 256 - 1)`.\n    function argsOnClone(address instance) internal view returns (bytes memory args) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x2d))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x2d, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnClone(instance, start, 2 ** 256 - 1)`.\n    function argsOnClone(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x2d))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x0d), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the clone with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnClone(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x0d), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x2d)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*              MINIMAL ERC1967 PROXY OPERATIONS              */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // Note: The ERC1967 proxy here is intended to be upgraded with UUPS.\n    // This is NOT the same as ERC1967Factory's transparent proxy, which includes admin logic.\n\n    /// @dev Deploys a minimal ERC1967 proxy with `implementation`.\n    function deployERC1967(address implementation) internal returns (address instance) {\n        instance = deployERC1967(0, implementation);\n    }\n\n    /// @dev Deploys a minimal ERC1967 proxy with `implementation`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967(uint256 value, address implementation)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------------+\n             * CREATION (34 bytes)                                                              |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize  | r                |                                 |\n             * 3d         | RETURNDATASIZE | 0 r              |                                 |\n             * 81         | DUP2           | r 0 r            |                                 |\n             * 60 offset  | PUSH1 offset   | o r 0 r          |                                 |\n             * 3d         | RETURNDATASIZE | 0 o r 0 r        |                                 |\n             * 39         | CODECOPY       | 0 r              | [0..runSize): runtime code      |\n             * 73 impl    | PUSH20 impl    | impl 0 r         | [0..runSize): runtime code      |\n             * 60 slotPos | PUSH1 slotPos  | slotPos impl 0 r | [0..runSize): runtime code      |\n             * 51         | MLOAD          | slot impl 0 r    | [0..runSize): runtime code      |\n             * 55         | SSTORE         | 0 r              | [0..runSize): runtime code      |\n             * f3         | RETURN         |                  | [0..runSize): runtime code      |\n             * ---------------------------------------------------------------------------------|\n             * RUNTIME (61 bytes)                                                               |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             *                                                                                  |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 3d         | RETURNDATASIZE | 0 cds            |                                 |\n             * 3d         | RETURNDATASIZE | 0 0 cds          |                                 |\n             * 37         | CALLDATACOPY   |                  | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | 0                |                                 |\n             * 3d         | RETURNDATASIZE | 0 0              |                                 |\n             * 36         | CALLDATASIZE   | cds 0 0          | [0..calldatasize): calldata     |\n             * 3d         | RETURNDATASIZE | 0 cds 0 0        | [0..calldatasize): calldata     |\n             * 7f slot    | PUSH32 slot    | s 0 cds 0 0      | [0..calldatasize): calldata     |\n             * 54         | SLOAD          | i 0 cds 0 0      | [0..calldatasize): calldata     |\n             * 5a         | GAS            | g i 0 cds 0 0    | [0..calldatasize): calldata     |\n             * f4         | DELEGATECALL   | succ             | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds succ         | [0..calldatasize): calldata     |\n             * 60 0x00    | PUSH1 0x00     | 0 rds succ       | [0..calldatasize): calldata     |\n             * 80         | DUP1           | 0 0 rds succ     | [0..calldatasize): calldata     |\n             * 3e         | RETURNDATACOPY | succ             | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 60 0x38    | PUSH1 0x38     | dest succ        | [0..returndatasize): returndata |\n             * 57         | JUMPI          |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * fd         | REVERT         |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  | [0..returndatasize): returndata |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * f3         | RETURN         |                  | [0..returndatasize): returndata |\n             * ---------------------------------------------------------------------------------+\n             */\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x20, 0x6009)\n            mstore(0x1e, implementation)\n            mstore(0x0a, 0x603d3d8160223d3973)\n            instance := create(value, 0x21, 0x5f)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n    function deployDeterministicERC1967(address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967(0, implementation, salt);\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x20, 0x6009)\n            mstore(0x1e, implementation)\n            mstore(0x0a, 0x603d3d8160223d3973)\n            instance := create2(value, 0x21, 0x5f, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967(address implementation, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967(0, implementation, salt);\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x20, 0x6009)\n            mstore(0x1e, implementation)\n            mstore(0x0a, 0x603d3d8160223d3973)\n            // Compute and store the bytecode hash.\n            mstore(add(m, 0x35), keccak256(0x21, 0x5f))\n            mstore(m, shl(88, address()))\n            mstore8(m, 0xff) // Write the prefix.\n            mstore(add(m, 0x15), salt)\n            instance := keccak256(m, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, 0x21, 0x5f, salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the initialization code of the minimal ERC1967 proxy of `implementation`.\n    function initCodeERC1967(address implementation) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x60), 0x3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f300)\n            mstore(add(c, 0x40), 0x55f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076cc)\n            mstore(add(c, 0x20), or(shl(24, implementation), 0x600951))\n            mstore(add(c, 0x09), 0x603d3d8160223d3973)\n            mstore(c, 0x5f) // Store the length.\n            mstore(0x40, add(c, 0x80)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the minimal ERC1967 proxy of `implementation`.\n    function initCodeHashERC1967(address implementation) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x20, 0x6009)\n            mstore(0x1e, implementation)\n            mstore(0x0a, 0x603d3d8160223d3973)\n            hash := keccak256(0x21, 0x5f)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967 proxy of `implementation`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967(implementation);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*    MINIMAL ERC1967 PROXY WITH IMMUTABLE ARGS OPERATIONS    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a minimal ERC1967 proxy with `implementation` and `args`.\n    function deployERC1967(address implementation, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        instance = deployERC1967(0, implementation, args);\n    }\n\n    /// @dev Deploys a minimal ERC1967 proxy with `implementation` and `args`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967(uint256 value, address implementation, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n            mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x16, 0x6009)\n            mstore(0x14, implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            instance := create(value, m, add(n, 0x60))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n    function deployDeterministicERC1967(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967(0, implementation, args, salt);\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n            mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x16, 0x6009)\n            mstore(0x14, implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            instance := create2(value, m, add(n, 0x60), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967(0, implementation, args, salt);\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n            mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x16, 0x6009)\n            mstore(0x14, implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(m, add(n, 0x60)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, m, add(n, 0x60), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the minimal ERC1967 proxy of `implementation` and `args`.\n    function initCodeERC1967(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffc2))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x80), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x60), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(c, 0x40), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(add(c, 0x20), 0x6009)\n            mstore(add(c, 0x1e), implementation)\n            mstore(add(c, 0x0a), add(0x61003d3d8160233d3973, shl(56, n)))\n            mstore(c, add(n, 0x60)) // Store the length.\n            mstore(add(c, add(n, 0x80)), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(c, add(n, 0xa0))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the minimal ERC1967 proxy of `implementation` and `args`.\n    function initCodeHashERC1967(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffc2))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x60), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x16, 0x6009)\n            mstore(0x14, implementation)\n            mstore(0x00, add(0x61003d3d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            hash := keccak256(m, add(n, 0x60))\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967 proxy of `implementation`, `args`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967(implementation, args);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnERC1967(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967(address instance) internal view returns (bytes memory args) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x3d))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x3d, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnERC1967(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x3d))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x1d), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the ERC1967 with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnERC1967(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x1d), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x3d)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                 ERC1967I PROXY OPERATIONS                  */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // Note: This proxy has a special code path that activates if `calldatasize() == 1`.\n    // This code path skips the delegatecall and directly returns the `implementation` address.\n    // The returned implementation is guaranteed to be valid if the keccak256 of the\n    // proxy's code is equal to `ERC1967I_CODE_HASH`.\n\n    /// @dev Deploys a ERC1967I proxy with `implementation`.\n    function deployERC1967I(address implementation) internal returns (address instance) {\n        instance = deployERC1967I(0, implementation);\n    }\n\n    /// @dev Deploys a ERC1967I proxy with `implementation`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967I(uint256 value, address implementation)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------------+\n             * CREATION (34 bytes)                                                              |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize  | r                |                                 |\n             * 3d         | RETURNDATASIZE | 0 r              |                                 |\n             * 81         | DUP2           | r 0 r            |                                 |\n             * 60 offset  | PUSH1 offset   | o r 0 r          |                                 |\n             * 3d         | RETURNDATASIZE | 0 o r 0 r        |                                 |\n             * 39         | CODECOPY       | 0 r              | [0..runSize): runtime code      |\n             * 73 impl    | PUSH20 impl    | impl 0 r         | [0..runSize): runtime code      |\n             * 60 slotPos | PUSH1 slotPos  | slotPos impl 0 r | [0..runSize): runtime code      |\n             * 51         | MLOAD          | slot impl 0 r    | [0..runSize): runtime code      |\n             * 55         | SSTORE         | 0 r              | [0..runSize): runtime code      |\n             * f3         | RETURN         |                  | [0..runSize): runtime code      |\n             * ---------------------------------------------------------------------------------|\n             * RUNTIME (82 bytes)                                                               |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             *                                                                                  |\n             * ::: check calldatasize ::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 58         | PC             | 1 cds            |                                 |\n             * 14         | EQ             | eqs              |                                 |\n             * 60 0x43    | PUSH1 0x43     | dest eqs         |                                 |\n             * 57         | JUMPI          |                  |                                 |\n             *                                                                                  |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 3d         | RETURNDATASIZE | 0 cds            |                                 |\n             * 3d         | RETURNDATASIZE | 0 0 cds          |                                 |\n             * 37         | CALLDATACOPY   |                  | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | 0                |                                 |\n             * 3d         | RETURNDATASIZE | 0 0              |                                 |\n             * 36         | CALLDATASIZE   | cds 0 0          | [0..calldatasize): calldata     |\n             * 3d         | RETURNDATASIZE | 0 cds 0 0        | [0..calldatasize): calldata     |\n             * 7f slot    | PUSH32 slot    | s 0 cds 0 0      | [0..calldatasize): calldata     |\n             * 54         | SLOAD          | i 0 cds 0 0      | [0..calldatasize): calldata     |\n             * 5a         | GAS            | g i 0 cds 0 0    | [0..calldatasize): calldata     |\n             * f4         | DELEGATECALL   | succ             | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds succ         | [0..calldatasize): calldata     |\n             * 60 0x00    | PUSH1 0x00     | 0 rds succ       | [0..calldatasize): calldata     |\n             * 80         | DUP1           | 0 0 rds succ     | [0..calldatasize): calldata     |\n             * 3e         | RETURNDATACOPY | succ             | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 60 0x3E    | PUSH1 0x3E     | dest succ        | [0..returndatasize): returndata |\n             * 57         | JUMPI          |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * fd         | REVERT         |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  | [0..returndatasize): returndata |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * f3         | RETURN         |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: implementation , return :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  |                                 |\n             * 60 0x20    | PUSH1 0x20     | 32               |                                 |\n             * 60 0x0F    | PUSH1 0x0F     | o 32             |                                 |\n             * 3d         | RETURNDATASIZE | 0 o 32           |                                 |\n             * 39         | CODECOPY       |                  | [0..32): implementation slot    |\n             * 3d         | RETURNDATASIZE | 0                | [0..32): implementation slot    |\n             * 51         | MLOAD          | slot             | [0..32): implementation slot    |\n             * 54         | SLOAD          | impl             | [0..32): implementation slot    |\n             * 3d         | RETURNDATASIZE | 0 impl           | [0..32): implementation slot    |\n             * 52         | MSTORE         |                  | [0..32): implementation address |\n             * 59         | MSIZE          | 32               | [0..32): implementation address |\n             * 3d         | RETURNDATASIZE | 0 32             | [0..32): implementation address |\n             * f3         | RETURN         |                  | [0..32): implementation address |\n             * ---------------------------------------------------------------------------------+\n             */\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n            instance := create(value, 0x0c, 0x74)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Deploys a deterministic ERC1967I proxy with `implementation` and `salt`.\n    function deployDeterministicERC1967I(address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967I(0, implementation, salt);\n    }\n\n    /// @dev Deploys a deterministic ERC1967I proxy with `implementation` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967I(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n            instance := create2(value, 0x0c, 0x74, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Creates a deterministic ERC1967I proxy with `implementation` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967I(address implementation, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967I(0, implementation, salt);\n    }\n\n    /// @dev Creates a deterministic ERC1967I proxy with `implementation` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967I(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n            // Compute and store the bytecode hash.\n            mstore(add(m, 0x35), keccak256(0x0c, 0x74))\n            mstore(m, shl(88, address()))\n            mstore8(m, 0xff) // Write the prefix.\n            mstore(add(m, 0x15), salt)\n            instance := keccak256(m, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, 0x0c, 0x74, salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the initialization code of the ERC1967I proxy of `implementation`.\n    function initCodeERC1967I(address implementation) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x74), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(c, 0x54), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(c, 0x34), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(add(c, 0x1d), implementation)\n            mstore(add(c, 0x09), 0x60523d8160223d3973)\n            mstore(add(c, 0x94), 0)\n            mstore(c, 0x74) // Store the length.\n            mstore(0x40, add(c, 0xa0)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967I proxy of `implementation`.\n    function initCodeHashERC1967I(address implementation) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n            hash := keccak256(0x0c, 0x74)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967I proxy of `implementation`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967I(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967I(implementation);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*       ERC1967I PROXY WITH IMMUTABLE ARGS OPERATIONS        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a minimal ERC1967I proxy with `implementation` and `args`.\n    function deployERC1967I(address implementation, bytes memory args) internal returns (address) {\n        return deployERC1967I(0, implementation, args);\n    }\n\n    /// @dev Deploys a minimal ERC1967I proxy with `implementation` and `args`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967I(uint256 value, address implementation, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n\n            mstore(add(m, 0x6b), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(m, 0x4b), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(m, 0x2b), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0xfe6100523d8160233d3973, shl(56, n)))\n\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            instance := create(value, add(m, add(0x15, lt(n, 0xffae))), add(0x75, n))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic ERC1967I proxy with `implementation`, `args`, and `salt`.\n    function deployDeterministicERC1967I(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967I(0, implementation, args, salt);\n    }\n\n    /// @dev Deploys a deterministic ERC1967I proxy with `implementation`, `args`, and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967I(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n\n            mstore(add(m, 0x6b), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(m, 0x4b), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(m, 0x2b), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0xfe6100523d8160233d3973, shl(56, n)))\n\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            instance := create2(value, add(m, add(0x15, lt(n, 0xffae))), add(0x75, n), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Creates a deterministic ERC1967I proxy with `implementation`, `args` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967I(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967I(0, implementation, args, salt);\n    }\n\n    /// @dev Creates a deterministic ERC1967I proxy with `implementation`, `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967I(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x75), n))\n            mstore(add(m, 0x55), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(m, 0x35), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(m, 0x15), 0x5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x16, 0x600f)\n            mstore(0x14, implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            mstore(gt(n, 0xffad), add(0xfe6100523d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(m, add(n, 0x75)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, m, add(0x75, n), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the ERC1967I proxy of `implementation` and `args`.\n    function initCodeERC1967I(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x95), i), mload(add(add(args, 0x20), i)))\n            }\n\n            mstore(add(c, 0x75), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(c, 0x55), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(c, 0x35), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(add(c, 0x1e), implementation)\n            mstore(add(c, 0x0a), add(0x6100523d8160233d3973, shl(56, n)))\n            mstore(add(c, add(n, 0x95)), 0)\n            mstore(c, add(0x75, n)) // Store the length.\n            mstore(0x40, add(c, add(n, 0xb5))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967I proxy of `implementation` and `args.\n    function initCodeHashERC1967I(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x75), i), mload(add(add(args, 0x20), i)))\n            }\n\n            mstore(add(m, 0x55), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(m, 0x35), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(m, 0x15), 0x5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x16, 0x600f)\n            mstore(0x14, implementation)\n            mstore(0x00, add(0x6100523d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            hash := keccak256(m, add(0x75, n))\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967I proxy of `implementation`, `args` with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967I(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967I(implementation, args);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnERC1967I(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967I(address instance) internal view returns (bytes memory args) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x52))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x52, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnERC1967I(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967I(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x52))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x32), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the ERC1967 with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnERC1967I(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x32), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x52)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                ERC1967 BOOTSTRAP OPERATIONS                */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // A bootstrap is a minimal UUPS implementation that allows an ERC1967 proxy\n    // pointing to it to be upgraded. The ERC1967 proxy can then be deployed to a\n    // deterministic address independent of the implementation:\n    // ```\n    //     address bootstrap = LibClone.erc1967Bootstrap();\n    //     address instance = LibClone.deployDeterministicERC1967(0, bootstrap, salt);\n    //     LibClone.bootstrapERC1967(bootstrap, implementation);\n    // ```\n\n    /// @dev Deploys the ERC1967 bootstrap if it has not been deployed.\n    function erc1967Bootstrap() internal returns (address) {\n        return erc1967Bootstrap(address(this));\n    }\n\n    /// @dev Deploys the ERC1967 bootstrap if it has not been deployed.\n    function erc1967Bootstrap(address authorizedUpgrader) internal returns (address bootstrap) {\n        bytes memory c = initCodeERC1967Bootstrap(authorizedUpgrader);\n        bootstrap = predictDeterministicAddress(keccak256(c), bytes32(0), address(this));\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(extcodesize(bootstrap)) {\n                if iszero(create2(0, add(c, 0x20), mload(c), 0)) {\n                    mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n    }\n\n    /// @dev Replaces the implementation at `instance`.\n    function bootstrapERC1967(address instance, address implementation) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, implementation)\n            if iszero(call(gas(), instance, 0, 0x0c, 0x14, codesize(), 0x00)) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Replaces the implementation at `instance`, and then call it with `data`.\n    function bootstrapERC1967AndCall(address instance, address implementation, bytes memory data)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let n := mload(data)\n            mstore(data, implementation)\n            if iszero(call(gas(), instance, 0, add(data, 0x0c), add(n, 0x14), codesize(), 0x00)) {\n                if iszero(returndatasize()) {\n                    mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                returndatacopy(mload(0x40), 0x00, returndatasize())\n                revert(mload(0x40), returndatasize())\n            }\n            mstore(data, n) // Restore the length of `data`.\n        }\n    }\n\n    /// @dev Returns the implementation address of the ERC1967 bootstrap for this contract.\n    function predictDeterministicAddressERC1967Bootstrap() internal view returns (address) {\n        return predictDeterministicAddressERC1967Bootstrap(address(this), address(this));\n    }\n\n    /// @dev Returns the implementation address of the ERC1967 bootstrap for this contract.\n    function predictDeterministicAddressERC1967Bootstrap(\n        address authorizedUpgrader,\n        address deployer\n    ) internal pure returns (address) {\n        bytes32 hash = initCodeHashERC1967Bootstrap(authorizedUpgrader);\n        return predictDeterministicAddress(hash, bytes32(0), deployer);\n    }\n\n    /// @dev Returns the initialization code of the ERC1967 bootstrap.\n    function initCodeERC1967Bootstrap(address authorizedUpgrader)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x80), 0x3d3560601c5af46047573d6000383e3d38fd0000000000000000000000000000)\n            mstore(add(c, 0x60), 0xa920a3ca505d382bbc55601436116049575b005b363d3d373d3d601436036014)\n            mstore(add(c, 0x40), 0x0338573d3560601c7f360894a13ba1a3210667c828492db98dca3e2076cc3735)\n            mstore(add(c, 0x20), authorizedUpgrader)\n            mstore(add(c, 0x0c), 0x606880600a3d393df3fe3373)\n            mstore(c, 0x72)\n            mstore(0x40, add(c, 0xa0))\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967 bootstrap.\n    function initCodeHashERC1967Bootstrap(address authorizedUpgrader)\n        internal\n        pure\n        returns (bytes32)\n    {\n        return keccak256(initCodeERC1967Bootstrap(authorizedUpgrader));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*          MINIMAL ERC1967 BEACON PROXY OPERATIONS           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // Note: If you use this proxy, you MUST make sure that the beacon is a\n    // valid ERC1967 beacon. This means that the beacon must always return a valid\n    // address upon a staticcall to `implementation()`, given sufficient gas.\n    // For performance, the deployment operations and the proxy assumes that the\n    // beacon is always valid and will NOT validate it.\n\n    /// @dev Deploys a minimal ERC1967 beacon proxy.\n    function deployERC1967BeaconProxy(address beacon) internal returns (address instance) {\n        instance = deployERC1967BeaconProxy(0, beacon);\n    }\n\n    /// @dev Deploys a minimal ERC1967 beacon proxy.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967BeaconProxy(uint256 value, address beacon)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------------+\n             * CREATION (34 bytes)                                                              |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize  | r                |                                 |\n             * 3d         | RETURNDATASIZE | 0 r              |                                 |\n             * 81         | DUP2           | r 0 r            |                                 |\n             * 60 offset  | PUSH1 offset   | o r 0 r          |                                 |\n             * 3d         | RETURNDATASIZE | 0 o r 0 r        |                                 |\n             * 39         | CODECOPY       | 0 r              | [0..runSize): runtime code      |\n             * 73 beac    | PUSH20 beac    | beac 0 r         | [0..runSize): runtime code      |\n             * 60 slotPos | PUSH1 slotPos  | slotPos beac 0 r | [0..runSize): runtime code      |\n             * 51         | MLOAD          | slot beac 0 r    | [0..runSize): runtime code      |\n             * 55         | SSTORE         | 0 r              | [0..runSize): runtime code      |\n             * f3         | RETURN         |                  | [0..runSize): runtime code      |\n             * ---------------------------------------------------------------------------------|\n             * RUNTIME (82 bytes)                                                               |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             *                                                                                  |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 3d         | RETURNDATASIZE | 0 cds            |                                 |\n             * 3d         | RETURNDATASIZE | 0 0 cds          |                                 |\n             * 37         | CALLDATACOPY   |                  | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | 0                |                                 |\n             * 3d         | RETURNDATASIZE | 0 0              |                                 |\n             * 36         | CALLDATASIZE   | cds 0 0          | [0..calldatasize): calldata     |\n             * 3d         | RETURNDATASIZE | 0 cds 0 0        | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ~~~~~~~ beacon staticcall sub procedure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 60 0x20       | PUSH1 0x20       | 32                          |                 |\n             * 36            | CALLDATASIZE     | cds 32                      |                 |\n             * 60 0x04       | PUSH1 0x04       | 4 cds 32                    |                 |\n             * 36            | CALLDATASIZE     | cds 4 cds 32                |                 |\n             * 63 0x5c60da1b | PUSH4 0x5c60da1b | 0x5c60da1b cds 4 cds 32     |                 |\n             * 60 0xe0       | PUSH1 0xe0       | 224 0x5c60da1b cds 4 cds 32 |                 |\n             * 1b            | SHL              | sel cds 4 cds 32            |                 |\n             * 36            | CALLDATASIZE     | cds sel cds 4 cds 32        |                 |\n             * 52            | MSTORE           | cds 4 cds 32                | sel             |\n             * 7f slot       | PUSH32 slot      | s cds 4 cds 32              | sel             |\n             * 54            | SLOAD            | beac cds 4 cds 32           | sel             |\n             * 5a            | GAS              | g beac cds 4 cds 32         | sel             |\n             * fa            | STATICCALL       | succ                        | impl            |\n             * 50            | POP              |                             | impl            |\n             * 36            | CALLDATASIZE     | cds                         | impl            |\n             * 51            | MLOAD            | impl                        | impl            |\n             * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 5a         | GAS            | g impl 0 cds 0 0 | [0..calldatasize): calldata     |\n             * f4         | DELEGATECALL   | succ             | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds succ         | [0..calldatasize): calldata     |\n             * 60 0x00    | PUSH1 0x00     | 0 rds succ       | [0..calldatasize): calldata     |\n             * 80         | DUP1           | 0 0 rds succ     | [0..calldatasize): calldata     |\n             * 3e         | RETURNDATACOPY | succ             | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 60 0x4d    | PUSH1 0x4d     | dest succ        | [0..returndatasize): returndata |\n             * 57         | JUMPI          |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * fd         | REVERT         |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  | [0..returndatasize): returndata |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * f3         | RETURN         |                  | [0..returndatasize): returndata |\n             * ---------------------------------------------------------------------------------+\n             */\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n            instance := create(value, 0x0c, 0x74)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `salt`.\n    function deployDeterministicERC1967BeaconProxy(address beacon, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967BeaconProxy(0, beacon, salt);\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967BeaconProxy(uint256 value, address beacon, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n            instance := create2(value, 0x0c, 0x74, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967BeaconProxy(address beacon, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967BeaconProxy(0, beacon, salt);\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967BeaconProxy(uint256 value, address beacon, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n            // Compute and store the bytecode hash.\n            mstore(add(m, 0x35), keccak256(0x0c, 0x74))\n            mstore(m, shl(88, address()))\n            mstore8(m, 0xff) // Write the prefix.\n            mstore(add(m, 0x15), salt)\n            instance := keccak256(m, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, 0x0c, 0x74, salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the initialization code of the minimal ERC1967 beacon proxy.\n    function initCodeERC1967BeaconProxy(address beacon) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x74), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(c, 0x54), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(c, 0x34), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(c, 0x1d), beacon)\n            mstore(add(c, 0x09), 0x60523d8160223d3973)\n            mstore(add(c, 0x94), 0)\n            mstore(c, 0x74) // Store the length.\n            mstore(0x40, add(c, 0xa0)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the minimal ERC1967 beacon proxy.\n    function initCodeHashERC1967BeaconProxy(address beacon) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n            hash := keccak256(0x0c, 0x74)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967 beacon proxy, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967BeaconProxy(\n        address beacon,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967BeaconProxy(beacon);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*    ERC1967 BEACON PROXY WITH IMMUTABLE ARGS OPERATIONS     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a minimal ERC1967 beacon proxy with `args`.\n    function deployERC1967BeaconProxy(address beacon, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        instance = deployERC1967BeaconProxy(0, beacon, args);\n    }\n\n    /// @dev Deploys a minimal ERC1967 beacon proxy with `args`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967BeaconProxy(uint256 value, address beacon, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n            mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n            instance := create(value, add(m, 0x16), add(n, 0x75))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n    function deployDeterministicERC1967BeaconProxy(address beacon, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967BeaconProxy(0, beacon, args, salt);\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967BeaconProxy(\n        uint256 value,\n        address beacon,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n            mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n            instance := create2(value, add(m, 0x16), add(n, 0x75), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967BeaconProxy(address beacon, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967BeaconProxy(0, beacon, args, salt);\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967BeaconProxy(\n        uint256 value,\n        address beacon,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n            mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(add(m, 0x16), add(n, 0x75)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, add(m, 0x16), add(n, 0x75), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the minimal ERC1967 beacon proxy.\n    function initCodeERC1967BeaconProxy(address beacon, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x95), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x75), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(c, 0x55), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(c, 0x35), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(c, 0x1e), beacon)\n            mstore(add(c, 0x0a), add(0x6100523d8160233d3973, shl(56, n)))\n            mstore(c, add(n, 0x75)) // Store the length.\n            mstore(add(c, add(n, 0x95)), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(c, add(n, 0xb5))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the minimal ERC1967 beacon proxy with `args`.\n    function initCodeHashERC1967BeaconProxy(address beacon, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x8b), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(m, 0x14), beacon)\n            mstore(m, add(0x6100523d8160233d3973, shl(56, n)))\n            hash := keccak256(add(m, 0x16), add(n, 0x75))\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967 beacon proxy with `args`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967BeaconProxy(\n        address beacon,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967BeaconProxy(beacon, args);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnERC1967BeaconProxy(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967BeaconProxy(address instance) internal view returns (bytes memory args) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x52))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x52, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnERC1967BeaconProxy(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967BeaconProxy(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x52))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x32), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the ERC1967 beacon proxy with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnERC1967BeaconProxy(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x32), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x52)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*              ERC1967I BEACON PROXY OPERATIONS              */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // Note: This proxy has a special code path that activates if `calldatasize() == 1`.\n    // This code path skips the delegatecall and directly returns the `implementation` address.\n    // The returned implementation is guaranteed to be valid if the keccak256 of the\n    // proxy's code is equal to `ERC1967_BEACON_PROXY_CODE_HASH`.\n    //\n    // If you use this proxy, you MUST make sure that the beacon is a\n    // valid ERC1967 beacon. This means that the beacon must always return a valid\n    // address upon a staticcall to `implementation()`, given sufficient gas.\n    // For performance, the deployment operations and the proxy assumes that the\n    // beacon is always valid and will NOT validate it.\n\n    /// @dev Deploys a ERC1967I beacon proxy.\n    function deployERC1967IBeaconProxy(address beacon) internal returns (address instance) {\n        instance = deployERC1967IBeaconProxy(0, beacon);\n    }\n\n    /// @dev Deploys a ERC1967I beacon proxy.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967IBeaconProxy(uint256 value, address beacon)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------------+\n             * CREATION (34 bytes)                                                              |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize  | r                |                                 |\n             * 3d         | RETURNDATASIZE | 0 r              |                                 |\n             * 81         | DUP2           | r 0 r            |                                 |\n             * 60 offset  | PUSH1 offset   | o r 0 r          |                                 |\n             * 3d         | RETURNDATASIZE | 0 o r 0 r        |                                 |\n             * 39         | CODECOPY       | 0 r              | [0..runSize): runtime code      |\n             * 73 beac    | PUSH20 beac    | beac 0 r         | [0..runSize): runtime code      |\n             * 60 slotPos | PUSH1 slotPos  | slotPos beac 0 r | [0..runSize): runtime code      |\n             * 51         | MLOAD          | slot beac 0 r    | [0..runSize): runtime code      |\n             * 55         | SSTORE         | 0 r              | [0..runSize): runtime code      |\n             * f3         | RETURN         |                  | [0..runSize): runtime code      |\n             * ---------------------------------------------------------------------------------|\n             * RUNTIME (87 bytes)                                                               |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             *                                                                                  |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 3d         | RETURNDATASIZE | 0 cds            |                                 |\n             * 3d         | RETURNDATASIZE | 0 0 cds          |                                 |\n             * 37         | CALLDATACOPY   |                  | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | 0                |                                 |\n             * 3d         | RETURNDATASIZE | 0 0              |                                 |\n             * 36         | CALLDATASIZE   | cds 0 0          | [0..calldatasize): calldata     |\n             * 3d         | RETURNDATASIZE | 0 cds 0 0        | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ~~~~~~~ beacon staticcall sub procedure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 60 0x20       | PUSH1 0x20       | 32                          |                 |\n             * 36            | CALLDATASIZE     | cds 32                      |                 |\n             * 60 0x04       | PUSH1 0x04       | 4 cds 32                    |                 |\n             * 36            | CALLDATASIZE     | cds 4 cds 32                |                 |\n             * 63 0x5c60da1b | PUSH4 0x5c60da1b | 0x5c60da1b cds 4 cds 32     |                 |\n             * 60 0xe0       | PUSH1 0xe0       | 224 0x5c60da1b cds 4 cds 32 |                 |\n             * 1b            | SHL              | sel cds 4 cds 32            |                 |\n             * 36            | CALLDATASIZE     | cds sel cds 4 cds 32        |                 |\n             * 52            | MSTORE           | cds 4 cds 32                | sel             |\n             * 7f slot       | PUSH32 slot      | s cds 4 cds 32              | sel             |\n             * 54            | SLOAD            | beac cds 4 cds 32           | sel             |\n             * 5a            | GAS              | g beac cds 4 cds 32         | sel             |\n             * fa            | STATICCALL       | succ                        | impl            |\n             * ~~~~~~ check calldatasize ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 36            | CALLDATASIZE     | cds succ                    |                 |\n             * 14            | EQ               |                             | impl            |\n             * 60 0x52       | PUSH1 0x52       |                             | impl            |\n             * 57            | JUMPI            |                             | impl            |\n             * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 36            | CALLDATASIZE     | cds                         | impl            |\n             * 51            | MLOAD            | impl                        | impl            |\n             * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 5a         | GAS            | g impl 0 cds 0 0 | [0..calldatasize): calldata     |\n             * f4         | DELEGATECALL   | succ             | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds succ         | [0..calldatasize): calldata     |\n             * 60 0x00    | PUSH1 0x00     | 0 rds succ       | [0..calldatasize): calldata     |\n             * 60 0x01    | PUSH1 0x01     | 1 0 rds succ     | [0..calldatasize): calldata     |\n             * 3e         | RETURNDATACOPY | succ             | [1..returndatasize): returndata |\n             *                                                                                  |\n             * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 60 0x52    | PUSH1 0x52     | dest succ        | [1..returndatasize): returndata |\n             * 57         | JUMPI          |                  | [1..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds              | [1..returndatasize): returndata |\n             * 60 0x01    | PUSH1 0x01     | 1 rds            | [1..returndatasize): returndata |\n             * fd         | REVERT         |                  | [1..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  | [1..returndatasize): returndata |\n             * 3d         | RETURNDATASIZE | rds              | [1..returndatasize): returndata |\n             * 60 0x01    | PUSH1 0x01     | 1 rds            | [1..returndatasize): returndata |\n             * f3         | RETURN         |                  | [1..returndatasize): returndata |\n             * ---------------------------------------------------------------------------------+\n             */\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n            instance := create(value, 0x07, 0x79)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Deploys a deterministic ERC1967I beacon proxy with `salt`.\n    function deployDeterministicERC1967IBeaconProxy(address beacon, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967IBeaconProxy(0, beacon, salt);\n    }\n\n    /// @dev Deploys a deterministic ERC1967I beacon proxy with `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967IBeaconProxy(uint256 value, address beacon, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n            instance := create2(value, 0x07, 0x79, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Creates a deterministic ERC1967I beacon proxy with `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967IBeaconProxy(address beacon, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967IBeaconProxy(0, beacon, salt);\n    }\n\n    /// @dev Creates a deterministic ERC1967I beacon proxy with `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967IBeaconProxy(uint256 value, address beacon, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n            // Compute and store the bytecode hash.\n            mstore(add(m, 0x35), keccak256(0x07, 0x79))\n            mstore(m, shl(88, address()))\n            mstore8(m, 0xff) // Write the prefix.\n            mstore(add(m, 0x15), salt)\n            instance := keccak256(m, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, 0x07, 0x79, salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the initialization code of the ERC1967I beacon proxy.\n    function initCodeERC1967IBeaconProxy(address beacon) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x79), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(c, 0x59), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(c, 0x39), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(c, 0x1d), beacon)\n            mstore(add(c, 0x09), 0x60573d8160223d3973)\n            mstore(add(c, 0x99), 0)\n            mstore(c, 0x79) // Store the length.\n            mstore(0x40, add(c, 0xa0)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967I beacon proxy.\n    function initCodeHashERC1967IBeaconProxy(address beacon) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n            hash := keccak256(0x07, 0x79)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967I beacon proxy, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967IBeaconProxy(\n        address beacon,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967IBeaconProxy(beacon);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*    ERC1967I BEACON PROXY WITH IMMUTABLE ARGS OPERATIONS    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a ERC1967I beacon proxy with `args.\n    function deployERC1967IBeaconProxy(address beacon, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        instance = deployERC1967IBeaconProxy(0, beacon, args);\n    }\n\n    /// @dev Deploys a ERC1967I beacon proxy with `args.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967IBeaconProxy(uint256 value, address beacon, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n            mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n            instance := create(value, add(m, 0x16), add(n, 0x7a))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic ERC1967I beacon proxy with `args` and `salt`.\n    function deployDeterministicERC1967IBeaconProxy(address beacon, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967IBeaconProxy(0, beacon, args, salt);\n    }\n\n    /// @dev Deploys a deterministic ERC1967I beacon proxy with `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967IBeaconProxy(\n        uint256 value,\n        address beacon,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n            mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n            instance := create2(value, add(m, 0x16), add(n, 0x7a), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Creates a deterministic ERC1967I beacon proxy with `args` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967IBeaconProxy(address beacon, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967IBeaconProxy(0, beacon, args, salt);\n    }\n\n    /// @dev Creates a deterministic ERC1967I beacon proxy with `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967IBeaconProxy(\n        uint256 value,\n        address beacon,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n            mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(add(m, 0x16), add(n, 0x7a)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, add(m, 0x16), add(n, 0x7a), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the ERC1967I beacon proxy with `args`.\n    function initCodeERC1967IBeaconProxy(address beacon, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffa8))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x9a), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x7a), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(c, 0x5a), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(c, 0x3a), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(c, 0x1e), beacon)\n            mstore(add(c, 0x0a), add(0x6100573d8160233d3973, shl(56, n)))\n            mstore(add(c, add(n, 0x9a)), 0)\n            mstore(c, add(n, 0x7a)) // Store the length.\n            mstore(0x40, add(c, add(n, 0xba))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967I beacon proxy with `args`.\n    function initCodeHashERC1967IBeaconProxy(address beacon, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let c := mload(0x40) // Cache the free memory pointer.\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffa8))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x90), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(c, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(c, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(c, 0x14), beacon)\n            mstore(c, add(0x6100573d8160233d3973, shl(56, n)))\n            hash := keccak256(add(c, 0x16), add(n, 0x7a))\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967I beacon proxy, with  `args` and salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967IBeaconProxy(\n        address beacon,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967IBeaconProxy(beacon, args);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnERC1967IBeaconProxy(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967IBeaconProxy(address instance)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x57))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x57, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnERC1967IBeaconProxy(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967IBeaconProxy(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x57))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x37), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the ERC1967I beacon proxy with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnERC1967IBeaconProxy(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x37), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x57)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      OTHER OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns `address(0)` if the implementation address cannot be determined.\n    function implementationOf(address instance) internal view returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            for { extcodecopy(instance, 0x00, 0x00, 0x57) } 1 {} {\n                if mload(0x2d) {\n                    // ERC1967I and ERC1967IBeaconProxy detection.\n                    if or(\n                        eq(keccak256(0x00, 0x52), ERC1967I_CODE_HASH),\n                        eq(keccak256(0x00, 0x57), ERC1967I_BEACON_PROXY_CODE_HASH)\n                    ) {\n                        pop(staticcall(gas(), instance, 0x00, 0x01, 0x00, 0x20))\n                        result := mload(0x0c)\n                        break\n                    }\n                }\n                // 0age clone detection.\n                result := mload(0x0b)\n                codecopy(0x0b, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n                if iszero(xor(keccak256(0x00, 0x2c), CLONE_CODE_HASH)) { break }\n                mstore(0x0b, result) // Restore the zeroized memory.\n                // CWIA detection.\n                result := mload(0x0a)\n                codecopy(0x0a, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n                if iszero(xor(keccak256(0x00, 0x2d), CWIA_CODE_HASH)) { break }\n                mstore(0x0a, result) // Restore the zeroized memory.\n                // PUSH0 clone detection.\n                result := mload(0x09)\n                codecopy(0x09, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n                result := shr(xor(keccak256(0x00, 0x2d), PUSH0_CLONE_CODE_HASH), result)\n                break\n            }\n            result := shr(96, result)\n            mstore(0x37, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the address when a contract with initialization code hash,\n    /// `hash`, is deployed with `salt`, by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddress(bytes32 hash, bytes32 salt, address deployer)\n        internal\n        pure\n        returns (address predicted)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, hash)\n            mstore(0x01, shl(96, deployer))\n            mstore(0x15, salt)\n            predicted := keccak256(0x00, 0x55)\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Requires that `salt` starts with either the zero address or `by`.\n    function checkStartsWith(bytes32 salt, address by) internal pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the salt does not start with the zero address or `by`.\n            if iszero(or(iszero(shr(96, salt)), eq(shr(96, shl(96, by)), shr(96, salt)))) {\n                mstore(0x00, 0x0c4549ef) // `SaltDoesNotStartWith()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Returns the `bytes32` at `offset` in `args`, without any bounds checks.\n    /// To load an address, you can use `address(bytes20(argLoad(args, offset)))`.\n    function argLoad(bytes memory args, uint256 offset) internal pure returns (bytes32 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := mload(add(add(args, 0x20), offset))\n        }\n    }\n}\n"},"lib/solady/src/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {CallContextChecker} from \"./CallContextChecker.sol\";\n\n/// @notice UUPS proxy mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/UUPSUpgradeable.sol)\n/// @author Modified from OpenZeppelin\n/// (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/utils/UUPSUpgradeable.sol)\n///\n/// @dev Note:\n/// - This implementation is intended to be used with ERC1967 proxies.\n/// See: `LibClone.deployERC1967` and related functions.\n/// - This implementation is NOT compatible with legacy OpenZeppelin proxies\n/// which do not store the implementation at `_ERC1967_IMPLEMENTATION_SLOT`.\nabstract contract UUPSUpgradeable is CallContextChecker {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The upgrade failed.\n    error UpgradeFailed();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Emitted when the proxy's implementation is upgraded.\n    event Upgraded(address indexed implementation);\n\n    /// @dev `keccak256(bytes(\"Upgraded(address)\"))`.\n    uint256 private constant _UPGRADED_EVENT_SIGNATURE =\n        0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ERC-1967 storage slot for the implementation in the proxy.\n    /// `uint256(keccak256(\"eip1967.proxy.implementation\")) - 1`.\n    bytes32 internal constant _ERC1967_IMPLEMENTATION_SLOT =\n        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      UUPS OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Please override this function to check if `msg.sender` is authorized\n    /// to upgrade the proxy to `newImplementation`, reverting if not.\n    /// ```\n    ///     function _authorizeUpgrade(address) internal override onlyOwner {}\n    /// ```\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /// @dev Returns the storage slot used by the implementation,\n    /// as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822).\n    ///\n    /// Note: The `notDelegated` modifier prevents accidental upgrades to\n    /// an implementation that is a proxy contract.\n    function proxiableUUID() public view virtual notDelegated returns (bytes32) {\n        // This function must always return `_ERC1967_IMPLEMENTATION_SLOT` to comply with ERC1967.\n        return _ERC1967_IMPLEMENTATION_SLOT;\n    }\n\n    /// @dev Upgrades the proxy's implementation to `newImplementation`.\n    /// Emits a {Upgraded} event.\n    ///\n    /// Note: Passing in empty `data` skips the delegatecall to `newImplementation`.\n    function upgradeToAndCall(address newImplementation, bytes calldata data)\n        public\n        payable\n        virtual\n        onlyProxy\n    {\n        _authorizeUpgrade(newImplementation);\n        /// @solidity memory-safe-assembly\n        assembly {\n            newImplementation := shr(96, shl(96, newImplementation)) // Clears upper 96 bits.\n            mstore(0x00, returndatasize())\n            mstore(0x01, 0x52d1902d) // `proxiableUUID()`.\n            let s := _ERC1967_IMPLEMENTATION_SLOT\n            // Check if `newImplementation` implements `proxiableUUID` correctly.\n            if iszero(eq(mload(staticcall(gas(), newImplementation, 0x1d, 0x04, 0x01, 0x20)), s)) {\n                mstore(0x01, 0x55299b49) // `UpgradeFailed()`.\n                revert(0x1d, 0x04)\n            }\n            // Emit the {Upgraded} event.\n            log2(codesize(), 0x00, _UPGRADED_EVENT_SIGNATURE, newImplementation)\n            sstore(s, newImplementation) // Updates the implementation.\n\n            // Perform a delegatecall to `newImplementation` if `data` is non-empty.\n            if data.length {\n                // Forwards the `data` to `newImplementation` via delegatecall.\n                let m := mload(0x40)\n                calldatacopy(m, data.offset, data.length)\n                if iszero(delegatecall(gas(), newImplementation, m, data.length, codesize(), 0x00))\n                {\n                    // Bubble up the revert if the call reverts.\n                    returndatacopy(m, 0x00, returndatasize())\n                    revert(m, returndatasize())\n                }\n            }\n        }\n    }\n}\n"},"src/Errors.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.13;\n\n/// @title Errors\n/// @author Polymarket\n/// @notice Custom errors shared across DepositWallet contracts.\nabstract contract Errors {\n    /// @notice Thrown when the caller is not authorized to perform the action.\n    error Unauthorized();\n\n    /// @notice Thrown when the provided owner address is invalid (e.g., zero address).\n    error InvalidOwner();\n\n    /// @notice Thrown when an ownership handover is expected but none is pending.\n    error NoPendingOwner();\n\n    /// @notice Thrown when a deadline has passed.\n    error Expired();\n\n    /// @notice Thrown when a signature fails verification.\n    error InvalidSignature();\n\n    /// @notice Thrown when the caller is not the factory contract.\n    error OnlyFactory();\n\n    /// @notice Thrown when a low-level call within a batch execution fails.\n    error BatchCallFailed(uint256 index, address target, bytes result);\n\n    /// @notice Thrown when a function restricted to self-calls is invoked externally.\n    error OnlySelf();\n\n    /// @notice Thrown when a batch contains zero calls.\n    error EmptyBatch();\n\n    /// @notice Thrown when the batch nonce does not match the wallet's current nonce.\n    error InvalidNonce();\n\n    /// @notice Thrown when the batch's wallet address does not match the executing wallet.\n    error InvalidWallet();\n\n    /// @notice Legacy error retained for ABI compatibility.\n    error SessionSignerUnauthorized();\n\n    /// @notice Thrown when a session signer attempts to call the wallet itself.\n    error SessionSignerSelfCallNotAllowed();\n\n    /// @notice Thrown when a session signer attempts to call the beacon — toggling the wallet's\n    ///         beacon-upgrade pin is an owner-only privilege.\n    error SessionSignerCannotCallBeacon();\n\n    /// @notice Thrown when the supplied coordinates are not a valid P-256 public key.\n    error InvalidPasskeyPublicKey(bytes32 x, bytes32 y);\n\n    /// @notice Thrown when the zero address is provided where a non-zero address is required.\n    error ZeroAddress();\n\n    /// @notice Thrown when the provided `validUntil` timestamp is not in the future.\n    error InvalidValidUntil();\n\n    /// @notice Thrown when a paused-only function is called while the wallet is not paused.\n    error NotPaused();\n\n    /// @notice Thrown when the timelock delay has not elapsed since the wallet was paused.\n    error TimelockInsufficientDelay();\n\n    /// @notice Thrown when the wallet cannot resolve its beacon from on-proxy state — i.e., the\n    ///         ERC-1967 beacon slot is empty AND the ERC-1967 implementation slot is either empty\n    ///         or points at an address with no code.\n    error BeaconUnresolvable();\n}\n"},"src/interfaces/IDepositWallet.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.13;\n\nimport {Batch} from \"@deposit-wallet/src/libraries/WalletLib.sol\";\n\n/// @title IDepositWallet\n/// @author Polymarket\n/// @notice Interface for the DepositWallet proxy contract.\ninterface IDepositWallet {\n    /*--------------------------------------------------------------\n                             INITIALIZER\n    --------------------------------------------------------------*/\n\n    /// @notice Initializes the wallet with a designated owner.\n    /// @param _owner The address to set as the wallet owner.\n    function initialize(address _owner) external;\n\n    /*--------------------------------------------------------------\n                                  VIEW\n    --------------------------------------------------------------*/\n\n    /// @notice Returns the wallet's current execution nonce.\n    /// @return The current nonce.\n    function nonce() external view returns (uint256);\n\n    /// @notice Returns the timestamp at which the wallet was paused.\n    /// @return The paused timestamp, or zero if not paused.\n    function paused() external view returns (uint256);\n\n    /// @notice Returns the timestamp until which a session signer is authorized.\n    /// @param _signer The session signer address to query.\n    /// @return The authorization expiry timestamp, or zero if not authorized.\n    function sessionSignerAuthorizedUntil(address _signer) external view returns (uint256);\n\n    /// @notice Returns a passkey session signer's public key and authorization expiry.\n    function passkeySessionSigner(bytes32 _passkeyId)\n        external\n        view\n        returns (bytes32 x, bytes32 y, uint256 validUntil);\n\n    /// @notice Returns the unique identifier assigned to this wallet at deployment.\n    /// @return The wallet ID decoded from the proxy's immutable args.\n    function id() external view returns (bytes32);\n\n    /// @notice Returns the factory contract that deployed this wallet.\n    /// @return The factory address decoded from the proxy's immutable args.\n    function factory() external view returns (address);\n\n    /// @notice Returns the current owner of the wallet.\n    /// @return The owner address.\n    function owner() external view returns (address);\n\n    /// @notice Returns the pending owner awaiting handover completion.\n    /// @return The pending owner address, or `address(0)` if none.\n    function pendingOwner() external view returns (address);\n\n    /// @notice Returns the deadline by which the pending owner must complete the handover.\n    /// @return The acceptance-deadline timestamp, or zero if no handover is pending.\n    function pendingOwnerDeadline() external view returns (uint256);\n\n    /// @notice Returns the per-handover nonce embedded in the EIP-712 signature.\n    /// @return The current handover nonce.\n    function pendingOwnerNonce() external view returns (uint256);\n\n    /// @notice Returns a stable magic identifying this contract as a `DepositWallet`.\n    /// @return The wallet identity magic.\n    function walletInterfaceId() external pure returns (bytes32);\n\n    /*--------------------------------------------------------------\n                             ONLY FACTORY\n    --------------------------------------------------------------*/\n\n    /// @notice Executes a signed batch of calls through the factory.\n    /// @dev Validates the batch (non-empty, correct wallet, nonce, deadline), verifies the EIP-712\n    ///      signature against the owner or an authorized session signer, then executes each call\n    ///      sequentially. Session signers are prevented from calling the wallet itself.\n    /// @param _batch The batch containing the target wallet, nonce, deadline, and calls.\n    /// @param _signature The EIP-712 signature authorizing the batch (owner or session signer).\n    function execute(Batch calldata _batch, bytes calldata _signature) external;\n\n    /*--------------------------------------------------------------\n                               ONLY SELF\n    --------------------------------------------------------------*/\n\n    /// @notice Authorizes a session signer until the specified timestamp.\n    /// @dev Can only be invoked via batch execution (self-call).\n    /// @param _sessionSigner The address to authorize as a session signer.\n    /// @param _validUntil The timestamp until which the session signer is valid.\n    function authorizeSessionSigner(address _sessionSigner, uint256 _validUntil) external;\n\n    /// @notice Revokes a session signer's authorization.\n    /// @dev Can only be invoked via batch execution (self-call).\n    /// @param _sessionSigner The session signer address to revoke.\n    function revokeSessionSigner(address _sessionSigner) external;\n\n    /// @notice Authorizes a P-256 passkey as a session signer.\n    function authorizePasskeySessionSigner(bytes32 _x, bytes32 _y, uint256 _validUntil) external;\n\n    /// @notice Revokes a passkey session signer.\n    function revokePasskeySessionSigner(bytes32 _passkeyId) external;\n\n    /// @notice Initiates a two-step ownership transfer to a new owner.\n    /// @dev Can only be invoked via batch execution (self-call). Records the on-chain deadline\n    ///      and bumps the per-handover nonce, invalidating any previously issued handover\n    ///      signature.\n    /// @param _newOwner The proposed new owner, distinct from the current owner and this wallet.\n    /// @param _deadline The timestamp by which the pending owner must complete the handover.\n    function transferOwnership(address _newOwner, uint256 _deadline) external;\n\n    /// @notice Cancels any pending ownership handover.\n    /// @dev Can only be invoked via batch execution (self-call).\n    function cancelOwnershipHandover() external;\n\n    /*--------------------------------------------------------------\n                           OWNERSHIP HANDOVER\n    --------------------------------------------------------------*/\n\n    /// @notice Completes a pending ownership transfer.\n    /// @dev Permissionless — anyone may submit, but the pending owner must have signed an\n    ///      EIP-712 `OwnershipHandover(newOwner, nonce)` message using the current\n    ///      {pendingOwnerNonce}, and the on-chain {pendingOwnerDeadline} must not have elapsed.\n    /// @param _signature The EIP-712 signature from the pending owner.\n    function completeOwnershipHandover(bytes calldata _signature) external;\n\n    /*--------------------------------------------------------------\n                               ONLY OWNER\n    --------------------------------------------------------------*/\n\n    /// @notice Pauses the wallet, recording the current timestamp.\n    /// @dev After pausing, the owner must wait for the timelock delay before calling\n    ///      paused-only functions (e.g., withdrawals, revocations).\n    function pause() external;\n\n    /// @notice Unpauses the wallet.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    function unpause() external;\n\n    /// @notice Withdraws native tokens from the wallet.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _to The recipient address.\n    /// @param _amount The amount of native tokens to withdraw.\n    function withdrawNative(address _to, uint256 _amount) external;\n\n    /// @notice Withdraws ERC-20 tokens from the wallet.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _token The ERC-20 token address.\n    /// @param _to The recipient address.\n    /// @param _amount The amount of tokens to withdraw.\n    function withdrawERC20(address _token, address _to, uint256 _amount) external;\n\n    /// @notice Batch-withdraws ERC-1155 tokens from the wallet.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _token The ERC-1155 token address.\n    /// @param _to The recipient address.\n    /// @param _ids The token IDs to withdraw.\n    /// @param _amounts The amounts for each token ID.\n    function withdrawERC1155(\n        address _token,\n        address _to,\n        uint256[] calldata _ids,\n        uint256[] calldata _amounts\n    ) external;\n\n    /// @notice Revokes an ERC-20 allowance by setting it to zero.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _token The ERC-20 token address.\n    /// @param _spender The spender whose allowance is revoked.\n    function revokeAllowance(address _token, address _spender) external;\n\n    /// @notice Revokes an ERC-1155 operator approval.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _token The ERC-1155 token address.\n    /// @param _operator The operator whose approval is revoked.\n    function revokeApprovalForAll(address _token, address _operator) external;\n\n    /// @notice Emergency revocation of a session signer by the owner.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _sessionSigner The session signer to revoke.\n    function revokeSessionSignerEmergency(address _sessionSigner) external;\n\n    /// @notice Emergency revocation of a passkey session signer by the owner.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    function revokePasskeySessionSignerEmergency(bytes32 _passkeyId) external;\n\n    /// @notice Opts the wallet out of beacon upgrades, pinning it to the current default\n    ///         implementation.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    function optOut() external;\n\n    /// @notice Clears the wallet's beacon-upgrade pin, rejoining the upgrade cohort.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    function optIn() external;\n\n    /*--------------------------------------------------------------\n                                ERC1271\n    --------------------------------------------------------------*/\n\n    /// @notice Validates a signature against the wallet owner or an authorized session signer.\n    /// @param _hash The hash that was signed.\n    /// @param _signature The signature to validate (may contain a session signer wrapper).\n    /// @return result `ERC1271_MAGIC_VALUE` if the signature is valid, otherwise a non-magic\n    /// value.\n    function isValidSignature(bytes32 _hash, bytes calldata _signature)\n        external\n        view\n        returns (bytes4 result);\n}\n"},"lib/solady/src/auth/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)\n///\n/// @dev Note:\n/// This implementation does NOT auto-initialize the owner to `msg.sender`.\n/// You MUST call the `_initializeOwner` in the constructor / initializer.\n///\n/// While the ownable portion follows\n/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,\n/// the nomenclature for the 2-step ownership handover may be unique to this codebase.\nabstract contract Ownable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The caller is not authorized to call the function.\n    error Unauthorized();\n\n    /// @dev The `newOwner` cannot be the zero address.\n    error NewOwnerIsZeroAddress();\n\n    /// @dev The `pendingOwner` does not have a valid handover request.\n    error NoHandoverRequest();\n\n    /// @dev Cannot double-initialize.\n    error AlreadyInitialized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.\n    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be\n    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),\n    /// despite it not being as lightweight as a single argument event.\n    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);\n\n    /// @dev An ownership handover to `pendingOwner` has been requested.\n    event OwnershipHandoverRequested(address indexed pendingOwner);\n\n    /// @dev The ownership handover to `pendingOwner` has been canceled.\n    event OwnershipHandoverCanceled(address indexed pendingOwner);\n\n    /// @dev `keccak256(bytes(\"OwnershipTransferred(address,address)\"))`.\n    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =\n        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverRequested(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =\n        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverCanceled(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =\n        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The owner slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_OWNER_SLOT_NOT\")))))`.\n    /// It is intentionally chosen to be a high value\n    /// to avoid collision with lower slots.\n    /// The choice of manual storage layout is to enable compatibility\n    /// with both regular and upgradeable contracts.\n    bytes32 internal constant _OWNER_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;\n\n    /// The ownership handover slot of `newOwner` is given by:\n    /// ```\n    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))\n    ///     let handoverSlot := keccak256(0x00, 0x20)\n    /// ```\n    /// It stores the expiry timestamp of the two-step ownership handover.\n    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.\n    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}\n\n    /// @dev Initializes the owner directly without authorization guard.\n    /// This function must be called upon initialization,\n    /// regardless of whether the contract is upgradeable or not.\n    /// This is to enable generalization to both regular and upgradeable contracts,\n    /// and to save gas in case the initial owner is not the caller.\n    /// For performance reasons, this function will not check if there\n    /// is an existing owner.\n    function _initializeOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                if sload(ownerSlot) {\n                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.\n                    revert(0x1c, 0x04)\n                }\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(_OWNER_SLOT, newOwner)\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        }\n    }\n\n    /// @dev Sets the owner directly without authorization guard.\n    function _setOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, newOwner)\n            }\n        }\n    }\n\n    /// @dev Throws if the sender is not the owner.\n    function _checkOwner() internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is not the stored owner, revert.\n            if iszero(eq(caller(), sload(_OWNER_SLOT))) {\n                mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Returns how long a two-step ownership handover is valid for in seconds.\n    /// Override to return a different value if needed.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {\n        return 48 * 3600;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Allows the owner to transfer the ownership to `newOwner`.\n    function transferOwnership(address newOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(shl(96, newOwner)) {\n                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _setOwner(newOwner);\n    }\n\n    /// @dev Allows the owner to renounce their ownership.\n    function renounceOwnership() public payable virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /// @dev Request a two-step ownership handover to the caller.\n    /// The request will automatically expire in 48 hours (172800 seconds) by default.\n    function requestOwnershipHandover() public payable virtual {\n        unchecked {\n            uint256 expires = block.timestamp + _ownershipHandoverValidFor();\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Compute and set the handover slot to `expires`.\n                mstore(0x0c, _HANDOVER_SLOT_SEED)\n                mstore(0x00, caller())\n                sstore(keccak256(0x0c, 0x20), expires)\n                // Emit the {OwnershipHandoverRequested} event.\n                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())\n            }\n        }\n    }\n\n    /// @dev Cancels the two-step ownership handover to the caller, if any.\n    function cancelOwnershipHandover() public payable virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x20), 0)\n            // Emit the {OwnershipHandoverCanceled} event.\n            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())\n        }\n    }\n\n    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.\n    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.\n    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            let handoverSlot := keccak256(0x0c, 0x20)\n            // If the handover does not exist, or has expired.\n            if gt(timestamp(), sload(handoverSlot)) {\n                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.\n                revert(0x1c, 0x04)\n            }\n            // Set the handover slot to 0.\n            sstore(handoverSlot, 0)\n        }\n        _setOwner(pendingOwner);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the owner of the contract.\n    function owner() public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_OWNER_SLOT)\n        }\n    }\n\n    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\n    function ownershipHandoverExpiresAt(address pendingOwner)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the handover slot.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            // Load the handover slot.\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by the owner.\n    modifier onlyOwner() virtual {\n        _checkOwner();\n        _;\n    }\n}\n"},"lib/solady/src/utils/CallContextChecker.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Call context checker mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/CallContextChecker.sol)\ncontract CallContextChecker {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The call is from an unauthorized call context.\n    error UnauthorizedCallContext();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         IMMUTABLES                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For checking if the context is a delegate call.\n    ///\n    /// Note: To enable use cases with an immutable default implementation in the bytecode,\n    /// (see: ERC6551Proxy), we don't require that the proxy address must match the\n    /// value stored in the implementation slot, which may not be initialized.\n    uint256 private immutable __self = uint256(uint160(address(this)));\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                    CALL CONTEXT CHECKS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // A proxy call can be either via a `delegatecall` to an implementation,\n    // or a 7702 call on an authority that points to a delegation.\n\n    /// @dev Returns whether the current call context is on a EIP7702 authority\n    /// (i.e. externally owned account).\n    function _onEIP7702Authority() internal view virtual returns (bool result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            extcodecopy(address(), 0x00, 0x00, 0x20)\n            // Note: Checking that it starts with hex\"ef01\" is the most general and futureproof.\n            // 7702 bytecode is `abi.encodePacked(hex\"ef01\", uint8(version), address(delegation))`.\n            result := eq(0xef01, shr(240, mload(0x00)))\n        }\n    }\n\n    /// @dev Returns the implementation of this contract.\n    function _selfImplementation() internal view virtual returns (address) {\n        return address(uint160(__self));\n    }\n\n    /// @dev Returns whether the current call context is on the implementation itself.\n    function _onImplementation() internal view virtual returns (bool) {\n        return __self == uint160(address(this));\n    }\n\n    /// @dev Requires that the current call context is performed via a EIP7702 authority.\n    function _checkOnlyEIP7702Authority() internal view virtual {\n        if (!_onEIP7702Authority()) _revertUnauthorizedCallContext();\n    }\n\n    /// @dev Requires that the current call context is performed via a proxy.\n    function _checkOnlyProxy() internal view virtual {\n        if (_onImplementation()) _revertUnauthorizedCallContext();\n    }\n\n    /// @dev Requires that the current call context is NOT performed via a proxy.\n    /// This is the opposite of `checkOnlyProxy`.\n    function _checkNotDelegated() internal view virtual {\n        if (!_onImplementation()) _revertUnauthorizedCallContext();\n    }\n\n    /// @dev Requires that the current call context is performed via a EIP7702 authority.\n    modifier onlyEIP7702Authority() virtual {\n        _checkOnlyEIP7702Authority();\n        _;\n    }\n\n    /// @dev Requires that the current call context is performed via a proxy.\n    modifier onlyProxy() virtual {\n        _checkOnlyProxy();\n        _;\n    }\n\n    /// @dev Requires that the current call context is NOT performed via a proxy.\n    /// This is the opposite of `onlyProxy`.\n    modifier notDelegated() virtual {\n        _checkNotDelegated();\n        _;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    function _revertUnauthorizedCallContext() private pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x9f03a026) // `UnauthorizedCallContext()`.\n            revert(0x1c, 0x04)\n        }\n    }\n}\n"},"src/libraries/WalletLib.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.13;\n\n/// @dev ERC-1271 magic value returned on successful signature validation.\n/// bytes4(keccak256(\"isValidSignature(bytes32,bytes)\"))\nbytes4 constant ERC1271_MAGIC_VALUE = 0x1626ba7e;\n\n/// @dev ERC-1271 value returned to signal an invalid signature.\nbytes4 constant ERC1271_INVALID_VALUE = 0xffffffff;\n\n/// @dev EIP-712 typehash for the `Call` struct.\nbytes32 constant CALL_TYPEHASH = keccak256(\"Call(address target,uint256 value,bytes data)\");\n\n/// @dev EIP-712 type name for the `Batch` struct, used in ERC-1271 nested signatures.\nstring constant BATCH_CONTENTS_NAME = \"Batch\";\n\n/// @dev EIP-712 type string for the `Batch` struct, including the nested `Call` type.\nstring constant BATCH_CONTENTS_TYPE =\n    \"Batch(address wallet,uint256 nonce,uint256 deadline,Call[] calls)Call(address target,uint256 value,bytes data)\";\n\n/// @dev EIP-712 typehash for the `Batch` struct.\nbytes32 constant BATCH_TYPEHASH = keccak256(bytes(BATCH_CONTENTS_TYPE));\n\n/// @notice A batch of calls to be executed by a DepositWallet.\n/// @dev Signed by the wallet owner or an authorized session signer using EIP-712.\nstruct Batch {\n    /// @dev The address of the wallet that will execute this batch.\n    address wallet;\n    /// @dev Replay-protection nonce; must equal the wallet's current nonce.\n    uint256 nonce;\n    /// @dev Timestamp after which the batch signature is no longer valid.\n    uint256 deadline;\n    /// @dev The ordered list of calls to execute.\n    Call[] calls;\n}\n\n/// @notice A single call within a batch.\nstruct Call {\n    /// @dev The target address to call.\n    address target;\n    /// @dev The ETH value to send with the call.\n    uint256 value;\n    /// @dev The calldata to send to the target.\n    bytes data;\n}\n\n/// @title WalletLib\n/// @author Polymarket\n/// @notice EIP-712 hashing utilities for `Batch` and `Call` structs.\nlibrary WalletLib {\n    /// @notice Computes the EIP-712 struct hash of a batch.\n    /// @param _batch The batch to hash.\n    /// @return The EIP-712 struct hash.\n    function hash(Batch memory _batch) internal pure returns (bytes32) {\n        return keccak256(\n            abi.encode(\n                BATCH_TYPEHASH, _batch.wallet, _batch.nonce, _batch.deadline, hash(_batch.calls)\n            )\n        );\n    }\n\n    /// @notice Computes the EIP-712 array hash of an array of calls.\n    /// @param _calls The calls to hash.\n    /// @return The keccak256 hash of the concatenated individual call hashes.\n    function hash(Call[] memory _calls) internal pure returns (bytes32) {\n        bytes32[] memory hashes = new bytes32[](_calls.length);\n        for (uint256 i; i < _calls.length; i++) {\n            hashes[i] = hash(_calls[i]);\n        }\n        return keccak256(abi.encodePacked(hashes));\n    }\n\n    /// @notice Computes the EIP-712 struct hash of a single call.\n    /// @param _call The call to hash.\n    /// @return The EIP-712 struct hash.\n    function hash(Call memory _call) internal pure returns (bytes32) {\n        return keccak256(\n            abi.encode(\n                CALL_TYPEHASH,\n                _call.target,\n                _call.value,\n                keccak256(_call.data) // bytes fields must be hashed\n            )\n        );\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.34+commit.80d5c536","compilerSettings":{"viaIR":false,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"osaka","remappings":["@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@solady/=lib/solady/","@forge-std/=lib/forge-std/","@deposit-wallet/src/=src/"]},"name":"DepositWalletFactory","fullyQualifiedName":"src/DepositWalletFactory.sol:DepositWalletFactory"},"abi":[{"type":"constructor","inputs":[{"name":"_beacon","type":"address","internalType":"address"},{"name":"_legacyImpl","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"ArrayLengthMismatch","type":"error","inputs":[]},{"name":"ImplementationNotAuthorized","type":"error","inputs":[]},{"name":"ImplementationNotDeployed","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"InvalidTimelockDelay","type":"error","inputs":[]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"OnlyAdmin","type":"error","inputs":[]},{"name":"OnlyLegacyDeployer","type":"error","inputs":[]},{"name":"OnlyOperator","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"UnauthorizedCallContext","type":"error","inputs":[]},{"name":"UpgradeFailed","type":"error","inputs":[]},{"name":"ZeroAddress","type":"error","inputs":[]},{"name":"ImplementationAuthorized","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ImplementationSet","type":"event","inputs":[{"name":"Implementation","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"ImplementationUnauthorized","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"OwnershipHandoverCanceled","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipHandoverRequested","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"oldOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RolesUpdated","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"roles","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"TimelockDelaySet","type":"event","inputs":[{"name":"timelockDelay","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"WalletDeployed","type":"event","inputs":[{"name":"wallet","type":"address","indexed":true,"internalType":"address"},{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"id","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"implementation","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"BEACON","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"LEGACY_IMPL","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"MAX_TIMELOCK_DELAY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"addAdmin","type":"function","inputs":[{"name":"_admin","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"addLegacyDeployer","type":"function","inputs":[{"name":"_legacyDeployer","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"addOperator","type":"function","inputs":[{"name":"_operator","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"authorizeImplementation","type":"function","inputs":[{"name":"_implementation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"authorizedImplementation","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"deploy","type":"function","inputs":[{"name":"_owners","type":"address[]","internalType":"address[]"},{"name":"_ids","type":"bytes32[]","internalType":"bytes32[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"deployLegacy","type":"function","inputs":[{"name":"_owners","type":"address[]","internalType":"address[]"},{"name":"_ids","type":"bytes32[]","internalType":"bytes32[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"grantRoles","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"hasAllRoles","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"hasAnyRole","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"implementation","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"_owner","type":"address","internalType":"address"},{"name":"_admin","type":"address","internalType":"address"},{"name":"_timelockDelay","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isAdmin","type":"function","inputs":[{"name":"_admin","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isLegacyDeployer","type":"function","inputs":[{"name":"_legacyDeployer","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isOperator","type":"function","inputs":[{"name":"_operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownershipHandoverExpiresAt","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"predictLegacyWalletAddress","type":"function","inputs":[{"name":"_id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"predictWalletAddress","type":"function","inputs":[{"name":"_id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"predictWalletAddress","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"_id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"proxy","type":"function","inputs":[{"name":"_batches","type":"tuple[]","components":[{"name":"wallet","type":"address","internalType":"address"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"calls","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"internalType":"struct Call[]"}],"internalType":"struct Batch[]"},{"name":"_signatures","type":"bytes[]","internalType":"bytes[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeAdmin","type":"function","inputs":[{"name":"_admin","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeLegacyDeployer","type":"function","inputs":[{"name":"_legacyDeployer","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeOperator","type":"function","inputs":[{"name":"_operator","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"renounceRoles","type":"function","inputs":[{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"revokeRoles","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"rolesOf","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"}],"outputs":[{"name":"roles","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"setImplementation","type":"function","inputs":[{"name":"_implementation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setTimelockDelay","type":"function","inputs":[{"name":"_timelockDelay","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"timelockDelay","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"unauthorizeImplementation","type":"function","inputs":[{"name":"_implementation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.34+commit.80d5c536"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_beacon","type":"address"},{"internalType":"address","name":"_legacyImpl","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"ArrayLengthMismatch","type":"error"},{"inputs":[],"name":"ImplementationNotAuthorized","type":"error"},{"inputs":[],"name":"ImplementationNotDeployed","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidTimelockDelay","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"OnlyAdmin","type":"error"},{"inputs":[],"name":"OnlyLegacyDeployer","type":"error"},{"inputs":[],"name":"OnlyOperator","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"UnauthorizedCallContext","type":"error"},{"inputs":[],"name":"UpgradeFailed","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"ImplementationAuthorized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"Implementation","type":"address"}],"name":"ImplementationSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"ImplementationUnauthorized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"roles","type":"uint256"}],"name":"RolesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"timelockDelay","type":"uint256"}],"name":"TimelockDelaySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"},{"indexed":false,"internalType":"address","name":"implementation","type":"address"}],"name":"WalletDeployed","type":"event"},{"inputs":[],"name":"BEACON","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LEGACY_IMPL","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TIMELOCK_DELAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"name":"addAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_legacyDeployer","type":"address"}],"name":"addLegacyDeployer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"addOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_implementation","type":"address"}],"name":"authorizeImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"authorizedImplementation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_owners","type":"address[]"},{"internalType":"bytes32[]","name":"_ids","type":"bytes32[]"}],"name":"deploy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_owners","type":"address[]"},{"internalType":"bytes32[]","name":"_ids","type":"bytes32[]"}],"name":"deployLegacy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"grantRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"hasAllRoles","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"hasAnyRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"uint256","name":"_timelockDelay","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_legacyDeployer","type":"address"}],"name":"isLegacyDeployer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_id","type":"bytes32"}],"name":"predictLegacyWalletAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_id","type":"bytes32"}],"name":"predictWalletAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bytes32","name":"_id","type":"bytes32"}],"name":"predictWalletAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Call[]","name":"calls","type":"tuple[]"}],"internalType":"struct Batch[]","name":"_batches","type":"tuple[]"},{"internalType":"bytes[]","name":"_signatures","type":"bytes[]"}],"name":"proxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"name":"removeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_legacyDeployer","type":"address"}],"name":"removeLegacyDeployer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"removeOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"renounceRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"revokeRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"rolesOf","outputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_implementation","type":"address"}],"name":"setImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_timelockDelay","type":"uint256"}],"name":"setTimelockDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"timelockDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_implementation","type":"address"}],"name":"unauthorizeImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"}],"devdoc":{"author":"Polymarket","details":"Uses a four-tier role model:      - **Owner**: can add/remove admins, manage implementations, and authorize UUPS upgrades                   of the factory itself.      - **Admin** (ROLE_0): can add/remove operators and legacy deployers, and configure the                   timelock delay.      - **Operator** (ROLE_1): can deploy beacon-shape wallets and proxy batch executions.      - **Legacy deployer** (ROLE_2): can deploy legacy-shape wallets via {deployLegacy}.      Two deploy paths, fed identical `args`/`salt`:      - {deploy} produces an ERC-1967 beacon proxy bound to {BEACON}.      - {deployLegacy} produces a plain ERC-1967 proxy embedding {LEGACY_IMPL}. This reproduces        the exact addresses the pre-beacon factory derived, because the address depends only on        (this factory's address, the embedded implementation, the Solady proxy template, the        id) — never on this factory's own bytecode. It exists for ids whose legacy address has        already been handed out, and for cross-chain recovery: deployed at the canonical        factory address on another chain, it mints a wallet at the identical address a user's        Polygon deposit wallet occupies.      Both paths fail closed: they revert unless the embedded implementation/beacon already      holds code, so a misordered rollout cannot mint ownerless, seizable wallets.      Storage slots 0/1/2 (`implementation`, `timelockDelay`, `authorizedImplementation`) are      preserved from prior versions so this contract can be installed as a UUPS upgrade on the      live factory proxy without corrupting state.","errors":{"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"ImplementationNotAuthorized()":[{"details":"Deprecated post-migration; only thrown by the legacy {setImplementation} surface."}],"ImplementationNotDeployed()":[{"details":"Fail-closed guard: deploying a proxy whose implementation/beacon is code-less would      let `initialize` silently succeed as a delegatecall to an empty account, minting an      ownerless wallet that anyone could later seize."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"UnauthorizedCallContext()":[{"details":"The call is from an unauthorized call context."}],"UpgradeFailed()":[{"details":"The upgrade failed."}]},"events":{"ImplementationAuthorized(address)":{"details":"Deprecated post-migration; only emitted while the legacy upgrade surface is in use      (e.g., authorizing {BeaconForwarder}).","params":{"implementation":"The address of the authorized implementation."}},"ImplementationSet(address)":{"details":"Deprecated; the legacy slot-0 `implementation` pointer is no longer consulted by      {DepositWalletFactory.deploy}.","params":{"Implementation":"The address of the new default implementation."}},"ImplementationUnauthorized(address)":{"details":"Deprecated post-migration; only emitted while the legacy upgrade surface is in use.","params":{"implementation":"The address of the unauthorized implementation."}},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized."},"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"RolesUpdated(address,uint256)":{"details":"The `user`'s roles is updated to `roles`. Each bit of `roles` represents whether the role is set."},"TimelockDelaySet(uint256)":{"params":{"timelockDelay":"The new timelock delay in seconds."}},"Upgraded(address)":{"details":"Emitted when the proxy's implementation is upgraded."},"WalletDeployed(address,address,bytes32,address)":{"params":{"id":"The unique identifier assigned to the wallet.","implementation":"The address embedded in the proxy: the beacon for beacon-shape                       wallets, or the legacy implementation for legacy-shape wallets.","owner":"The initial owner of the wallet.","wallet":"The address of the newly deployed wallet proxy."}}},"kind":"dev","methods":{"addAdmin(address)":{"params":{"_admin":"The address to grant the admin role."}},"addLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to grant the legacy-deployer role."}},"addOperator(address)":{"params":{"_operator":"The address to grant the operator role."}},"authorizeImplementation(address)":{"details":"Used during the migration window to authorize {BeaconForwarder}; will be deprecated      after the migration window closes.","params":{"_implementation":"The implementation address to authorize."}},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"constructor":{"details":"Sets the beacon and legacy implementation, then disables initializers on the      implementation contract.","params":{"_beacon":"The beacon contract address for beacon-shape wallets.","_legacyImpl":"The legacy implementation address embedded in legacy-shape wallets."}},"deploy(address[],bytes32[])":{"details":"It is the operator's responsibility to ensure that each `_id` is unique.      Duplicate IDs will cause the deployment to revert because the deterministic      address is already occupied. Note: beacon-shape and legacy-shape wallets for the      same `_id` live at DIFFERENT addresses (different proxy template), so they never      collide; the operator must dedupe IDs across both shapes off-chain.","params":{"_ids":"The unique identifiers for each wallet.","_owners":"The initial owner addresses for each wallet."}},"deployLegacy(address[],bytes32[])":{"details":"Restricted to the legacy-deployer role (ROLE_2), granted independently of the      operator role. Used for ids whose legacy address has already been handed out, and for      cross-chain recovery: a wallet deployed here lands at the same address the user's      Polygon deposit wallet occupies. The resulting wallet runs {LEGACY_IMPL} (the V1      implementation). See {deploy} for the ID-uniqueness and cross-shape notes.","params":{"_ids":"The unique identifiers for each wallet.","_owners":"The initial owner addresses for each wallet."}},"grantRoles(address,uint256)":{"details":"Allows the owner to grant `user` `roles`. If the `user` already has a role, then it will be an no-op for the role."},"hasAllRoles(address,uint256)":{"details":"Returns whether `user` has all of `roles`."},"hasAnyRole(address,uint256)":{"details":"Returns whether `user` has any of `roles`."},"initialize(address,address,uint256)":{"params":{"_admin":"The address to grant the initial admin role.","_owner":"The address to set as the factory owner.","_timelockDelay":"The initial timelock delay in seconds."}},"isAdmin(address)":{"params":{"_admin":"The address to check."},"returns":{"_0":"True if the address is an admin."}},"isLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to check."},"returns":{"_0":"True if the address is a legacy deployer."}},"isOperator(address)":{"params":{"_operator":"The address to check."},"returns":{"_0":"True if the address is an operator."}},"owner()":{"details":"Returns the owner of the contract."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"predictLegacyWalletAddress(bytes32)":{"details":"This matches the address the pre-beacon factory assigned to a wallet with the same      `_id` — including, on other chains, the address of the user's Polygon wallet —      enabling cross-chain recovery at the identical address.","params":{"_id":"The unique identifier for the wallet."},"returns":{"_0":"The predicted legacy wallet address."}},"predictWalletAddress(address,bytes32)":{"details":"Deprecated; retained for ABI compatibility. The first argument is ignored — wallets      are now beacon proxies bound to {BEACON}. Prefer {predictWalletAddress(bytes32)}.","params":{"_id":"The unique identifier for the wallet."},"returns":{"_0":"The predicted wallet proxy address."}},"predictWalletAddress(bytes32)":{"details":"This returns the address derived from the beacon-proxy template. For the address of a      legacy-shape (ERC-1967, UUPS) wallet, use {predictLegacyWalletAddress} — the two      shapes live at different deterministic addresses because the proxy bytecode (and      therefore the CREATE2 derivation) differs.","params":{"_id":"The unique identifier for the wallet."},"returns":{"_0":"The predicted beacon-proxy wallet address."}},"proxiableUUID()":{"details":"Returns the storage slot used by the implementation, as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822). Note: The `notDelegated` modifier prevents accidental upgrades to an implementation that is a proxy contract."},"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])":{"details":"Each batch is forwarded to its target wallet's `execute` function. Works for both      wallet shapes (the `Batch` layout is identical across the legacy and current      implementations).","params":{"_batches":"The batches to execute.","_signatures":"The corresponding signatures for each batch."}},"removeAdmin(address)":{"params":{"_admin":"The address to remove the admin role from."}},"removeLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to remove the legacy-deployer role from."}},"removeOperator(address)":{"params":{"_operator":"The address to remove the operator role from."}},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"renounceRoles(uint256)":{"details":"Allow the caller to remove their own roles. If the caller does not have a role, then it will be an no-op for the role."},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"revokeRoles(address,uint256)":{"details":"Allows the owner to remove `user` `roles`. If the `user` does not have a role, then it will be an no-op for the role."},"rolesOf(address)":{"details":"Returns the roles of `user`."},"setImplementation(address)":{"details":"Deprecated; retained for ABI compatibility. Has no effect on {deploy} (which uses      {BEACON}) or {deployLegacy} (which uses {LEGACY_IMPL}).","params":{"_implementation":"The new default implementation address."}},"setTimelockDelay(uint256)":{"params":{"_timelockDelay":"The new timelock delay in seconds."}},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"unauthorizeImplementation(address)":{"details":"Used during the migration window; will be deprecated after the window closes.","params":{"_implementation":"The implementation address to unauthorize."}},"upgradeToAndCall(address,bytes)":{"details":"Upgrades the proxy's implementation to `newImplementation`. Emits a {Upgraded} event. Note: Passing in empty `data` skips the delegatecall to `newImplementation`."}},"stateVariables":{"LEGACY_IMPL":{"details":"Set to the live legacy DepositWallet implementation so {deployLegacy} reproduces the      exact wallet addresses the pre-beacon factory deployed."},"authorizedImplementation":{"details":"Legacy-shape wallets gate their `upgrade` self-call on this mapping. Used during the      migration window to authorize {BeaconForwarder} so existing UUPS wallets can opt into      the beacon. Will be deprecated after the migration window closes."},"implementation":{"details":"Deprecated; not consulted by {deploy} or {deployLegacy}. Retained only to preserve      slot 0 of the live factory proxy so this contract can be installed via UUPS upgrade      in place."}},"title":"DepositWalletFactory","version":1},"userdoc":{"errors":{"ArrayLengthMismatch()":[{"notice":"Thrown when paired input arrays have mismatched lengths."}],"ImplementationNotAuthorized()":[{"notice":"Thrown when an implementation has not been authorized."}],"ImplementationNotDeployed()":[{"notice":"Thrown when a deploy target (the beacon, its resolved implementation, or the         legacy implementation) has no code."}],"InvalidTimelockDelay()":[{"notice":"Thrown when the provided timelock delay is zero or exceeds the maximum."}],"OnlyAdmin()":[{"notice":"Thrown when the caller does not have the admin role."}],"OnlyLegacyDeployer()":[{"notice":"Thrown when the caller does not have the legacy-deployer role."}],"OnlyOperator()":[{"notice":"Thrown when the caller does not have the operator role."}],"ZeroAddress()":[{"notice":"Thrown when the zero address is provided where a non-zero address is required."}]},"events":{"ImplementationAuthorized(address)":{"notice":"Emitted when a wallet implementation is added to the authorized set."},"ImplementationSet(address)":{"notice":"Emitted when the default wallet implementation is updated."},"ImplementationUnauthorized(address)":{"notice":"Emitted when a wallet implementation is removed from the authorized set."},"TimelockDelaySet(uint256)":{"notice":"Emitted when the timelock delay is updated."},"WalletDeployed(address,address,bytes32,address)":{"notice":"Emitted when a new deposit wallet is deployed."}},"kind":"user","methods":{"BEACON()":{"notice":"The beacon that resolves the implementation for beacon-shape wallets."},"LEGACY_IMPL()":{"notice":"The implementation embedded in legacy-shape (ERC-1967, UUPS) wallets."},"MAX_TIMELOCK_DELAY()":{"notice":"The maximum allowed timelock delay (7 days)."},"addAdmin(address)":{"notice":"Grants the admin role to an address."},"addLegacyDeployer(address)":{"notice":"Grants the legacy-deployer role to an address."},"addOperator(address)":{"notice":"Grants the operator role to an address."},"authorizeImplementation(address)":{"notice":"Authorizes an implementation address for legacy UUPS upgrades."},"authorizedImplementation(address)":{"notice":"Tracks which implementation addresses are authorized for legacy UUPS upgrades."},"deploy(address[],bytes32[])":{"notice":"Deploys one or more beacon-shape deposit wallets with deterministic addresses."},"deployLegacy(address[],bytes32[])":{"notice":"Deploys one or more legacy-shape (ERC-1967, UUPS) deposit wallets with         deterministic addresses that match the pre-beacon factory's derivation."},"implementation()":{"notice":"Legacy default wallet implementation pointer."},"initialize(address,address,uint256)":{"notice":"Initializes the factory with an owner, admin, and timelock delay."},"isAdmin(address)":{"notice":"Returns whether the given address has the admin role."},"isLegacyDeployer(address)":{"notice":"Returns whether the given address has the legacy-deployer role."},"isOperator(address)":{"notice":"Returns whether the given address has the operator role."},"predictLegacyWalletAddress(bytes32)":{"notice":"Predicts the deterministic address of a legacy-shape (ERC-1967) wallet before         deployment."},"predictWalletAddress(address,bytes32)":{"notice":"Predicts the deterministic address of a wallet before deployment."},"predictWalletAddress(bytes32)":{"notice":"Predicts the deterministic address of a beacon-proxy wallet before deployment."},"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])":{"notice":"Proxies batch execution to one or more wallets."},"removeAdmin(address)":{"notice":"Removes the admin role from an address."},"removeLegacyDeployer(address)":{"notice":"Removes the legacy-deployer role from an address."},"removeOperator(address)":{"notice":"Removes the operator role from an address."},"setImplementation(address)":{"notice":"Sets the legacy slot-0 implementation pointer."},"setTimelockDelay(uint256)":{"notice":"Sets the timelock delay for paused wallet operations."},"timelockDelay()":{"notice":"The delay in seconds that must elapse after pausing before the owner can         execute paused-only operations on a wallet."},"unauthorizeImplementation(address)":{"notice":"Removes an implementation address from the authorized set."}},"notice":"Factory contract for deploying and managing DepositWallets. Deploys ERC-1967         beacon proxies going forward, and can also deploy legacy ERC-1967 (UUPS-shaped)         wallets at the exact deterministic addresses the pre-beacon factory used.","version":1}},"settings":{"compilationTarget":{"src/DepositWalletFactory.sol":"DepositWalletFactory"},"evmVersion":"osaka","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":1000000},"remappings":[":@deposit-wallet/src/=src/",":@forge-std/=lib/forge-std/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":@solady/=lib/solady/"]},"sources":{"lib/solady/src/auth/Ownable.sol":{"keccak256":"0xc208cdd9de02bbf4b5edad18b88e23a2be7ff56d2287d5649329dc7cda64b9a3","license":"MIT","urls":["bzz-raw://e8fba079cc7230c617f7493a2e97873f88e59a53a5018fcb2e2b6ac42d8aa5a3","dweb:/ipfs/QmTXg8GSt8hsK2cZhbPFrund1mrwVdkLQmEPoQaFy4fhjs"]},"lib/solady/src/auth/OwnableRoles.sol":{"keccak256":"0x34fc1e43ab0c413faea47d5198d49879ccafd3a46c1657083ec79e3f4ca4359d","license":"MIT","urls":["bzz-raw://539e93fa51da529c6fdf122a68239652e98a4e31eaf5a08868339404878a095d","dweb:/ipfs/Qmf4SGkn3LDLGAeFmuSnETrQUCa8g8h2dSoukCwyj36yy6"]},"lib/solady/src/utils/CallContextChecker.sol":{"keccak256":"0xc54c743a03f4909826712e9c6b683ca95e8b0c120c55284a9e3572621ebd734b","license":"MIT","urls":["bzz-raw://3d3138009aba3d2fd310636f3cc1d6029e970c57ddb74693bebf2a02d3e6f12d","dweb:/ipfs/QmauMpcVDyQqVnAUF75DXy831LvtxyFS7GND7kge1Zgw55"]},"lib/solady/src/utils/Initializable.sol":{"keccak256":"0x58ee7b2e966232ca1ca9e9e705d8afcefa83fe29d37d6f8361d73015a9db1fe4","license":"MIT","urls":["bzz-raw://59f134cb038e0a547f0a3dbfe9c9b6939f7b39dff64646a79e8cf2dd6ba14f80","dweb:/ipfs/QmfXt149JQEWsYbLUkS9iLP6kGZqzHYyMg7SsLUUPgafEb"]},"lib/solady/src/utils/LibClone.sol":{"keccak256":"0x1b96fd03a3948155bd2fe95dc4980930c759b174026e18f11bc8e88d55ae030e","license":"MIT","urls":["bzz-raw://64998d16472a127031ee6a796ed9afcf13dd662afd30eb4d3e2a42c2bc9fd204","dweb:/ipfs/QmTXHGy9t8YTW96tjiZ8RBqmijXUTqc1JznEBqHv8Duc4A"]},"lib/solady/src/utils/UUPSUpgradeable.sol":{"keccak256":"0x63899eaf1a24713464b8084ada33a83c4b7db789fe83ae22f016e39646bee361","license":"MIT","urls":["bzz-raw://617fa735ffa8ba31051745614a508abd69d2cfc1b1bc1eb3c772865db5f7ce65","dweb:/ipfs/QmR1pQbHPyXcLbFm2vHrXBs1qRFrGC22gF7wWYamYy8aaE"]},"src/DepositWalletFactory.sol":{"keccak256":"0x99c4cc0d174b518a9066fd3f174bff453e06103b9a8047b4e2fb9bfafe2d832e","license":"BUSL-1.1","urls":["bzz-raw://6755650fde18027cccdac1fd5d0615cf5eac55cd4f0a94c4d944d267aeef326e","dweb:/ipfs/QmYBXh8h13nTP7Khsdy54ycvVGw3mjnbgUE1LX8EEVmERe"]},"src/Errors.sol":{"keccak256":"0x641a144833da4937522a190855503388ac8f43ca1de0db64fc646798f4fa46c8","license":"BUSL-1.1","urls":["bzz-raw://4b40f47875b47995bd7f9e1aba2e724a69c0363d3c801403899630d9f5488365","dweb:/ipfs/Qmf82WsA6eQRRUj6ScpmuBVKavimg3UL85yXYfL6QjdEPu"]},"src/interfaces/IDepositWallet.sol":{"keccak256":"0x4174ab48008387f1ce4c1a5c6052a98968488885b592a9a850dcb6a3a5552f6a","license":"BUSL-1.1","urls":["bzz-raw://ce3320db306c334438f015d12dc94ab7f5f18faf17964cd4d68fa863380ea246","dweb:/ipfs/QmTmjXvJCisVUsHizdcin7VNAQc5arRZphL2f9ALNuH2F7"]},"src/libraries/WalletLib.sol":{"keccak256":"0xcd683a9161bc4c17220d606569729ddc5047cc22c3197e2e5e3130aac488e0f2","license":"BUSL-1.1","urls":["bzz-raw://8096a63d894b255d64d4151ae9edf935c0c2e21a637613f6c068cce4c03008c4","dweb:/ipfs/QmQHHxFJmYD5DGVXLz1kHwwBzF1J5D5wLnod7KzcTi5Ts5"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":4137,"label":"implementation","offset":0,"contract":"src/DepositWalletFactory.sol:DepositWalletFactory"},{"slot":"1","type":"t_uint256","astId":4140,"label":"timelockDelay","offset":0,"contract":"src/DepositWalletFactory.sol:DepositWalletFactory"},{"slot":"2","type":"t_mapping(t_address,t_bool)","astId":4145,"label":"authorizedImplementation","offset":0,"contract":"src/DepositWalletFactory.sol:DepositWalletFactory"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","errors":{"OnlyAdmin()":[{"notice":"Thrown when the caller does not have the admin role."}],"ZeroAddress()":[{"notice":"Thrown when the zero address is provided where a non-zero address is required."}],"OnlyOperator()":[{"notice":"Thrown when the caller does not have the operator role."}],"OnlyLegacyDeployer()":[{"notice":"Thrown when the caller does not have the legacy-deployer role."}],"ArrayLengthMismatch()":[{"notice":"Thrown when paired input arrays have mismatched lengths."}],"InvalidTimelockDelay()":[{"notice":"Thrown when the provided timelock delay is zero or exceeds the maximum."}],"ImplementationNotDeployed()":[{"notice":"Thrown when a deploy target (the beacon, its resolved implementation, or the         legacy implementation) has no code."}],"ImplementationNotAuthorized()":[{"notice":"Thrown when an implementation has not been authorized."}]},"events":{"TimelockDelaySet(uint256)":{"notice":"Emitted when the timelock delay is updated."},"ImplementationSet(address)":{"notice":"Emitted when the default wallet implementation is updated."},"ImplementationAuthorized(address)":{"notice":"Emitted when a wallet implementation is added to the authorized set."},"ImplementationUnauthorized(address)":{"notice":"Emitted when a wallet implementation is removed from the authorized set."},"WalletDeployed(address,address,bytes32,address)":{"notice":"Emitted when a new deposit wallet is deployed."}},"notice":"Factory contract for deploying and managing DepositWallets. Deploys ERC-1967         beacon proxies going forward, and can also deploy legacy ERC-1967 (UUPS-shaped)         wallets at the exact deterministic addresses the pre-beacon factory used.","methods":{"BEACON()":{"notice":"The beacon that resolves the implementation for beacon-shape wallets."},"LEGACY_IMPL()":{"notice":"The implementation embedded in legacy-shape (ERC-1967, UUPS) wallets."},"timelockDelay()":{"notice":"The delay in seconds that must elapse after pausing before the owner can         execute paused-only operations on a wallet."},"implementation()":{"notice":"Legacy default wallet implementation pointer."},"isAdmin(address)":{"notice":"Returns whether the given address has the admin role."},"addAdmin(address)":{"notice":"Grants the admin role to an address."},"isOperator(address)":{"notice":"Returns whether the given address has the operator role."},"MAX_TIMELOCK_DELAY()":{"notice":"The maximum allowed timelock delay (7 days)."},"addOperator(address)":{"notice":"Grants the operator role to an address."},"removeAdmin(address)":{"notice":"Removes the admin role from an address."},"removeOperator(address)":{"notice":"Removes the operator role from an address."},"isLegacyDeployer(address)":{"notice":"Returns whether the given address has the legacy-deployer role."},"setTimelockDelay(uint256)":{"notice":"Sets the timelock delay for paused wallet operations."},"addLegacyDeployer(address)":{"notice":"Grants the legacy-deployer role to an address."},"setImplementation(address)":{"notice":"Sets the legacy slot-0 implementation pointer."},"deploy(address[],bytes32[])":{"notice":"Deploys one or more beacon-shape deposit wallets with deterministic addresses."},"predictWalletAddress(bytes32)":{"notice":"Predicts the deterministic address of a beacon-proxy wallet before deployment."},"removeLegacyDeployer(address)":{"notice":"Removes the legacy-deployer role from an address."},"authorizeImplementation(address)":{"notice":"Authorizes an implementation address for legacy UUPS upgrades."},"authorizedImplementation(address)":{"notice":"Tracks which implementation addresses are authorized for legacy UUPS upgrades."},"deployLegacy(address[],bytes32[])":{"notice":"Deploys one or more legacy-shape (ERC-1967, UUPS) deposit wallets with         deterministic addresses that match the pre-beacon factory's derivation."},"unauthorizeImplementation(address)":{"notice":"Removes an implementation address from the authorized set."},"initialize(address,address,uint256)":{"notice":"Initializes the factory with an owner, admin, and timelock delay."},"predictLegacyWalletAddress(bytes32)":{"notice":"Predicts the deterministic address of a legacy-shape (ERC-1967) wallet before         deployment."},"predictWalletAddress(address,bytes32)":{"notice":"Predicts the deterministic address of a wallet before deployment."},"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])":{"notice":"Proxies batch execution to one or more wallets."}},"version":1},"devdoc":{"kind":"dev","title":"DepositWalletFactory","author":"Polymarket","errors":{"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"UpgradeFailed()":[{"details":"The upgrade failed."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"UnauthorizedCallContext()":[{"details":"The call is from an unauthorized call context."}],"ImplementationNotDeployed()":[{"details":"Fail-closed guard: deploying a proxy whose implementation/beacon is code-less would      let `initialize` silently succeed as a delegatecall to an empty account, minting an      ownerless wallet that anyone could later seize."}],"ImplementationNotAuthorized()":[{"details":"Deprecated post-migration; only thrown by the legacy {setImplementation} surface."}]},"events":{"Upgraded(address)":{"details":"Emitted when the proxy's implementation is upgraded."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized."},"TimelockDelaySet(uint256)":{"params":{"timelockDelay":"The new timelock delay in seconds."}},"ImplementationSet(address)":{"params":{"Implementation":"The address of the new default implementation."},"details":"Deprecated; the legacy slot-0 `implementation` pointer is no longer consulted by      {DepositWalletFactory.deploy}."},"RolesUpdated(address,uint256)":{"details":"The `user`'s roles is updated to `roles`. Each bit of `roles` represents whether the role is set."},"ImplementationAuthorized(address)":{"params":{"implementation":"The address of the authorized implementation."},"details":"Deprecated post-migration; only emitted while the legacy upgrade surface is in use      (e.g., authorizing {BeaconForwarder})."},"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"ImplementationUnauthorized(address)":{"params":{"implementation":"The address of the unauthorized implementation."},"details":"Deprecated post-migration; only emitted while the legacy upgrade surface is in use."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"WalletDeployed(address,address,bytes32,address)":{"params":{"id":"The unique identifier assigned to the wallet.","owner":"The initial owner of the wallet.","wallet":"The address of the newly deployed wallet proxy.","implementation":"The address embedded in the proxy: the beacon for beacon-shape                       wallets, or the legacy implementation for legacy-shape wallets."}}},"details":"Uses a four-tier role model:      - **Owner**: can add/remove admins, manage implementations, and authorize UUPS upgrades                   of the factory itself.      - **Admin** (ROLE_0): can add/remove operators and legacy deployers, and configure the                   timelock delay.      - **Operator** (ROLE_1): can deploy beacon-shape wallets and proxy batch executions.      - **Legacy deployer** (ROLE_2): can deploy legacy-shape wallets via {deployLegacy}.      Two deploy paths, fed identical `args`/`salt`:      - {deploy} produces an ERC-1967 beacon proxy bound to {BEACON}.      - {deployLegacy} produces a plain ERC-1967 proxy embedding {LEGACY_IMPL}. This reproduces        the exact addresses the pre-beacon factory derived, because the address depends only on        (this factory's address, the embedded implementation, the Solady proxy template, the        id) — never on this factory's own bytecode. It exists for ids whose legacy address has        already been handed out, and for cross-chain recovery: deployed at the canonical        factory address on another chain, it mints a wallet at the identical address a user's        Polygon deposit wallet occupies.      Both paths fail closed: they revert unless the embedded implementation/beacon already      holds code, so a misordered rollout cannot mint ownerless, seizable wallets.      Storage slots 0/1/2 (`implementation`, `timelockDelay`, `authorizedImplementation`) are      preserved from prior versions so this contract can be installed as a UUPS upgrade on the      live factory proxy without corrupting state.","methods":{"owner()":{"details":"Returns the owner of the contract."},"constructor":{"params":{"_beacon":"The beacon contract address for beacon-shape wallets.","_legacyImpl":"The legacy implementation address embedded in legacy-shape wallets."},"details":"Sets the beacon and legacy implementation, then disables initializers on the      implementation contract."},"proxiableUUID()":{"details":"Returns the storage slot used by the implementation, as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822). Note: The `notDelegated` modifier prevents accidental upgrades to an implementation that is a proxy contract."},"isAdmin(address)":{"params":{"_admin":"The address to check."},"returns":{"_0":"True if the address is an admin."}},"rolesOf(address)":{"details":"Returns the roles of `user`."},"addAdmin(address)":{"params":{"_admin":"The address to grant the admin role."}},"isOperator(address)":{"params":{"_operator":"The address to check."},"returns":{"_0":"True if the address is an operator."}},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"addOperator(address)":{"params":{"_operator":"The address to grant the operator role."}},"removeAdmin(address)":{"params":{"_admin":"The address to remove the admin role from."}},"renounceRoles(uint256)":{"details":"Allow the caller to remove their own roles. If the caller does not have a role, then it will be an no-op for the role."},"removeOperator(address)":{"params":{"_operator":"The address to remove the operator role from."}},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"isLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to check."},"returns":{"_0":"True if the address is a legacy deployer."}},"setTimelockDelay(uint256)":{"params":{"_timelockDelay":"The new timelock delay in seconds."}},"addLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to grant the legacy-deployer role."}},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"setImplementation(address)":{"params":{"_implementation":"The new default implementation address."},"details":"Deprecated; retained for ABI compatibility. Has no effect on {deploy} (which uses      {BEACON}) or {deployLegacy} (which uses {LEGACY_IMPL})."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"deploy(address[],bytes32[])":{"params":{"_ids":"The unique identifiers for each wallet.","_owners":"The initial owner addresses for each wallet."},"details":"It is the operator's responsibility to ensure that each `_id` is unique.      Duplicate IDs will cause the deployment to revert because the deterministic      address is already occupied. Note: beacon-shape and legacy-shape wallets for the      same `_id` live at DIFFERENT addresses (different proxy template), so they never      collide; the operator must dedupe IDs across both shapes off-chain."},"grantRoles(address,uint256)":{"details":"Allows the owner to grant `user` `roles`. If the `user` already has a role, then it will be an no-op for the role."},"hasAnyRole(address,uint256)":{"details":"Returns whether `user` has any of `roles`."},"hasAllRoles(address,uint256)":{"details":"Returns whether `user` has all of `roles`."},"revokeRoles(address,uint256)":{"details":"Allows the owner to remove `user` `roles`. If the `user` does not have a role, then it will be an no-op for the role."},"predictWalletAddress(bytes32)":{"params":{"_id":"The unique identifier for the wallet."},"details":"This returns the address derived from the beacon-proxy template. For the address of a      legacy-shape (ERC-1967, UUPS) wallet, use {predictLegacyWalletAddress} — the two      shapes live at different deterministic addresses because the proxy bytecode (and      therefore the CREATE2 derivation) differs.","returns":{"_0":"The predicted beacon-proxy wallet address."}},"removeLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to remove the legacy-deployer role from."}},"upgradeToAndCall(address,bytes)":{"details":"Upgrades the proxy's implementation to `newImplementation`. Emits a {Upgraded} event. Note: Passing in empty `data` skips the delegatecall to `newImplementation`."},"authorizeImplementation(address)":{"params":{"_implementation":"The implementation address to authorize."},"details":"Used during the migration window to authorize {BeaconForwarder}; will be deprecated      after the migration window closes."},"deployLegacy(address[],bytes32[])":{"params":{"_ids":"The unique identifiers for each wallet.","_owners":"The initial owner addresses for each wallet."},"details":"Restricted to the legacy-deployer role (ROLE_2), granted independently of the      operator role. Used for ids whose legacy address has already been handed out, and for      cross-chain recovery: a wallet deployed here lands at the same address the user's      Polygon deposit wallet occupies. The resulting wallet runs {LEGACY_IMPL} (the V1      implementation). See {deploy} for the ID-uniqueness and cross-shape notes."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"unauthorizeImplementation(address)":{"params":{"_implementation":"The implementation address to unauthorize."},"details":"Used during the migration window; will be deprecated after the window closes."},"initialize(address,address,uint256)":{"params":{"_admin":"The address to grant the initial admin role.","_owner":"The address to set as the factory owner.","_timelockDelay":"The initial timelock delay in seconds."}},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"predictLegacyWalletAddress(bytes32)":{"params":{"_id":"The unique identifier for the wallet."},"details":"This matches the address the pre-beacon factory assigned to a wallet with the same      `_id` — including, on other chains, the address of the user's Polygon wallet —      enabling cross-chain recovery at the identical address.","returns":{"_0":"The predicted legacy wallet address."}},"predictWalletAddress(address,bytes32)":{"params":{"_id":"The unique identifier for the wallet."},"details":"Deprecated; retained for ABI compatibility. The first argument is ignored — wallets      are now beacon proxies bound to {BEACON}. Prefer {predictWalletAddress(bytes32)}.","returns":{"_0":"The predicted wallet proxy address."}},"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])":{"params":{"_batches":"The batches to execute.","_signatures":"The corresponding signatures for each batch."},"details":"Each batch is forwarded to its target wallet's `execute` function. Works for both      wallet shapes (the `Batch` layout is identical across the legacy and current      implementations)."}},"version":1,"stateVariables":{"LEGACY_IMPL":{"details":"Set to the live legacy DepositWallet implementation so {deployLegacy} reproduces the      exact wallet addresses the pre-beacon factory deployed."},"implementation":{"details":"Deprecated; not consulted by {deploy} or {deployLegacy}. Retained only to preserve      slot 0 of the live factory proxy so this contract can be installed via UUPS upgrade      in place."},"authorizedImplementation":{"details":"Legacy-shape wallets gate their `upgrade` self-call on this mapping. Used during the      migration window to authorize {BeaconForwarder} so existing UUPS wallets can opt into      the beacon. Will be deprecated after the migration window closes."}}},"sourceIds":{"src/Errors.sol":{"id":7},"src/libraries/WalletLib.sol":{"id":9},"src/DepositWalletFactory.sol":{"id":6},"lib/solady/src/auth/Ownable.sol":{"id":0},"lib/solady/src/utils/LibClone.sol":{"id":4},"src/interfaces/IDepositWallet.sol":{"id":8},"lib/solady/src/auth/OwnableRoles.sol":{"id":1},"lib/solady/src/utils/Initializable.sol":{"id":3},"lib/solady/src/utils/UUPSUpgradeable.sol":{"id":5},"lib/solady/src/utils/CallContextChecker.sol":{"id":2}},"additionalInput":null,"stdJsonInput":{"sources":{"src/Errors.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.13;\n\n/// @title Errors\n/// @author Polymarket\n/// @notice Custom errors shared across DepositWallet contracts.\nabstract contract Errors {\n    /// @notice Thrown when the caller is not authorized to perform the action.\n    error Unauthorized();\n\n    /// @notice Thrown when the provided owner address is invalid (e.g., zero address).\n    error InvalidOwner();\n\n    /// @notice Thrown when an ownership handover is expected but none is pending.\n    error NoPendingOwner();\n\n    /// @notice Thrown when a deadline has passed.\n    error Expired();\n\n    /// @notice Thrown when a signature fails verification.\n    error InvalidSignature();\n\n    /// @notice Thrown when the caller is not the factory contract.\n    error OnlyFactory();\n\n    /// @notice Thrown when a low-level call within a batch execution fails.\n    error BatchCallFailed(uint256 index, address target, bytes result);\n\n    /// @notice Thrown when a function restricted to self-calls is invoked externally.\n    error OnlySelf();\n\n    /// @notice Thrown when a batch contains zero calls.\n    error EmptyBatch();\n\n    /// @notice Thrown when the batch nonce does not match the wallet's current nonce.\n    error InvalidNonce();\n\n    /// @notice Thrown when the batch's wallet address does not match the executing wallet.\n    error InvalidWallet();\n\n    /// @notice Legacy error retained for ABI compatibility.\n    error SessionSignerUnauthorized();\n\n    /// @notice Thrown when a session signer attempts to call the wallet itself.\n    error SessionSignerSelfCallNotAllowed();\n\n    /// @notice Thrown when a session signer attempts to call the beacon — toggling the wallet's\n    ///         beacon-upgrade pin is an owner-only privilege.\n    error SessionSignerCannotCallBeacon();\n\n    /// @notice Thrown when the supplied coordinates are not a valid P-256 public key.\n    error InvalidPasskeyPublicKey(bytes32 x, bytes32 y);\n\n    /// @notice Thrown when the zero address is provided where a non-zero address is required.\n    error ZeroAddress();\n\n    /// @notice Thrown when the provided `validUntil` timestamp is not in the future.\n    error InvalidValidUntil();\n\n    /// @notice Thrown when a paused-only function is called while the wallet is not paused.\n    error NotPaused();\n\n    /// @notice Thrown when the timelock delay has not elapsed since the wallet was paused.\n    error TimelockInsufficientDelay();\n\n    /// @notice Thrown when the wallet cannot resolve its beacon from on-proxy state — i.e., the\n    ///         ERC-1967 beacon slot is empty AND the ERC-1967 implementation slot is either empty\n    ///         or points at an address with no code.\n    error BeaconUnresolvable();\n}\n"},"src/libraries/WalletLib.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.13;\n\n/// @dev ERC-1271 magic value returned on successful signature validation.\n/// bytes4(keccak256(\"isValidSignature(bytes32,bytes)\"))\nbytes4 constant ERC1271_MAGIC_VALUE = 0x1626ba7e;\n\n/// @dev ERC-1271 value returned to signal an invalid signature.\nbytes4 constant ERC1271_INVALID_VALUE = 0xffffffff;\n\n/// @dev EIP-712 typehash for the `Call` struct.\nbytes32 constant CALL_TYPEHASH = keccak256(\"Call(address target,uint256 value,bytes data)\");\n\n/// @dev EIP-712 type name for the `Batch` struct, used in ERC-1271 nested signatures.\nstring constant BATCH_CONTENTS_NAME = \"Batch\";\n\n/// @dev EIP-712 type string for the `Batch` struct, including the nested `Call` type.\nstring constant BATCH_CONTENTS_TYPE =\n    \"Batch(address wallet,uint256 nonce,uint256 deadline,Call[] calls)Call(address target,uint256 value,bytes data)\";\n\n/// @dev EIP-712 typehash for the `Batch` struct.\nbytes32 constant BATCH_TYPEHASH = keccak256(bytes(BATCH_CONTENTS_TYPE));\n\n/// @notice A batch of calls to be executed by a DepositWallet.\n/// @dev Signed by the wallet owner or an authorized session signer using EIP-712.\nstruct Batch {\n    /// @dev The address of the wallet that will execute this batch.\n    address wallet;\n    /// @dev Replay-protection nonce; must equal the wallet's current nonce.\n    uint256 nonce;\n    /// @dev Timestamp after which the batch signature is no longer valid.\n    uint256 deadline;\n    /// @dev The ordered list of calls to execute.\n    Call[] calls;\n}\n\n/// @notice A single call within a batch.\nstruct Call {\n    /// @dev The target address to call.\n    address target;\n    /// @dev The ETH value to send with the call.\n    uint256 value;\n    /// @dev The calldata to send to the target.\n    bytes data;\n}\n\n/// @title WalletLib\n/// @author Polymarket\n/// @notice EIP-712 hashing utilities for `Batch` and `Call` structs.\nlibrary WalletLib {\n    /// @notice Computes the EIP-712 struct hash of a batch.\n    /// @param _batch The batch to hash.\n    /// @return The EIP-712 struct hash.\n    function hash(Batch memory _batch) internal pure returns (bytes32) {\n        return keccak256(\n            abi.encode(\n                BATCH_TYPEHASH, _batch.wallet, _batch.nonce, _batch.deadline, hash(_batch.calls)\n            )\n        );\n    }\n\n    /// @notice Computes the EIP-712 array hash of an array of calls.\n    /// @param _calls The calls to hash.\n    /// @return The keccak256 hash of the concatenated individual call hashes.\n    function hash(Call[] memory _calls) internal pure returns (bytes32) {\n        bytes32[] memory hashes = new bytes32[](_calls.length);\n        for (uint256 i; i < _calls.length; i++) {\n            hashes[i] = hash(_calls[i]);\n        }\n        return keccak256(abi.encodePacked(hashes));\n    }\n\n    /// @notice Computes the EIP-712 struct hash of a single call.\n    /// @param _call The call to hash.\n    /// @return The EIP-712 struct hash.\n    function hash(Call memory _call) internal pure returns (bytes32) {\n        return keccak256(\n            abi.encode(\n                CALL_TYPEHASH,\n                _call.target,\n                _call.value,\n                keccak256(_call.data) // bytes fields must be hashed\n            )\n        );\n    }\n}\n"},"src/DepositWalletFactory.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.34;\n\nimport {OwnableRoles} from \"@solady/src/auth/OwnableRoles.sol\";\nimport {Initializable} from \"@solady/src/utils/Initializable.sol\";\nimport {LibClone} from \"@solady/src/utils/LibClone.sol\";\nimport {UUPSUpgradeable} from \"@solady/src/utils/UUPSUpgradeable.sol\";\n\nimport {Errors} from \"@deposit-wallet/src/Errors.sol\";\nimport {IDepositWallet, Batch} from \"@deposit-wallet/src/interfaces/IDepositWallet.sol\";\n\n/// @notice Minimal interface for resolving a beacon's current implementation.\ninterface IBeacon {\n    /// @notice Returns the implementation the beacon currently resolves to.\n    function implementation() external view returns (address);\n}\n\n/// @title DepositWalletFactoryErrors\n/// @author Polymarket\n/// @notice Custom errors for {DepositWalletFactory}.\nabstract contract DepositWalletFactoryErrors {\n    /// @notice Thrown when the caller does not have the admin role.\n    error OnlyAdmin();\n\n    /// @notice Thrown when the caller does not have the operator role.\n    error OnlyOperator();\n\n    /// @notice Thrown when the caller does not have the legacy-deployer role.\n    error OnlyLegacyDeployer();\n\n    /// @notice Thrown when paired input arrays have mismatched lengths.\n    error ArrayLengthMismatch();\n\n    /// @notice Thrown when an implementation has not been authorized.\n    /// @dev Deprecated post-migration; only thrown by the legacy {setImplementation} surface.\n    error ImplementationNotAuthorized();\n\n    /// @notice Thrown when the provided timelock delay is zero or exceeds the maximum.\n    error InvalidTimelockDelay();\n\n    /// @notice Thrown when a deploy target (the beacon, its resolved implementation, or the\n    ///         legacy implementation) has no code.\n    /// @dev Fail-closed guard: deploying a proxy whose implementation/beacon is code-less would\n    ///      let `initialize` silently succeed as a delegatecall to an empty account, minting an\n    ///      ownerless wallet that anyone could later seize.\n    error ImplementationNotDeployed();\n}\n\n/// @title DepositWalletFactoryEvents\n/// @author Polymarket\n/// @notice Events emitted by {DepositWalletFactory}.\nabstract contract DepositWalletFactoryEvents {\n    /// @notice Emitted when a wallet implementation is added to the authorized set.\n    /// @dev Deprecated post-migration; only emitted while the legacy upgrade surface is in use\n    ///      (e.g., authorizing {BeaconForwarder}).\n    /// @param implementation The address of the authorized implementation.\n    event ImplementationAuthorized(address indexed implementation);\n\n    /// @notice Emitted when the default wallet implementation is updated.\n    /// @dev Deprecated; the legacy slot-0 `implementation` pointer is no longer consulted by\n    ///      {DepositWalletFactory.deploy}.\n    /// @param Implementation The address of the new default implementation.\n    event ImplementationSet(address Implementation);\n\n    /// @notice Emitted when a wallet implementation is removed from the authorized set.\n    /// @dev Deprecated post-migration; only emitted while the legacy upgrade surface is in use.\n    /// @param implementation The address of the unauthorized implementation.\n    event ImplementationUnauthorized(address indexed implementation);\n\n    /// @notice Emitted when the timelock delay is updated.\n    /// @param timelockDelay The new timelock delay in seconds.\n    event TimelockDelaySet(uint256 timelockDelay);\n\n    /// @notice Emitted when a new deposit wallet is deployed.\n    /// @param wallet The address of the newly deployed wallet proxy.\n    /// @param owner The initial owner of the wallet.\n    /// @param id The unique identifier assigned to the wallet.\n    /// @param implementation The address embedded in the proxy: the beacon for beacon-shape\n    ///                       wallets, or the legacy implementation for legacy-shape wallets.\n    event WalletDeployed(\n        address indexed wallet, address indexed owner, bytes32 indexed id, address implementation\n    );\n}\n\n/// @title DepositWalletFactory\n/// @author Polymarket\n/// @notice Factory contract for deploying and managing DepositWallets. Deploys ERC-1967\n///         beacon proxies going forward, and can also deploy legacy ERC-1967 (UUPS-shaped)\n///         wallets at the exact deterministic addresses the pre-beacon factory used.\n/// @dev Uses a four-tier role model:\n///      - **Owner**: can add/remove admins, manage implementations, and authorize UUPS upgrades\n///                   of the factory itself.\n///      - **Admin** (ROLE_0): can add/remove operators and legacy deployers, and configure the\n///                   timelock delay.\n///      - **Operator** (ROLE_1): can deploy beacon-shape wallets and proxy batch executions.\n///      - **Legacy deployer** (ROLE_2): can deploy legacy-shape wallets via {deployLegacy}.\n///\n///      Two deploy paths, fed identical `args`/`salt`:\n///      - {deploy} produces an ERC-1967 beacon proxy bound to {BEACON}.\n///      - {deployLegacy} produces a plain ERC-1967 proxy embedding {LEGACY_IMPL}. This reproduces\n///        the exact addresses the pre-beacon factory derived, because the address depends only on\n///        (this factory's address, the embedded implementation, the Solady proxy template, the\n///        id) — never on this factory's own bytecode. It exists for ids whose legacy address has\n///        already been handed out, and for cross-chain recovery: deployed at the canonical\n///        factory address on another chain, it mints a wallet at the identical address a user's\n///        Polygon deposit wallet occupies.\n///\n///      Both paths fail closed: they revert unless the embedded implementation/beacon already\n///      holds code, so a misordered rollout cannot mint ownerless, seizable wallets.\n///\n///      Storage slots 0/1/2 (`implementation`, `timelockDelay`, `authorizedImplementation`) are\n///      preserved from prior versions so this contract can be installed as a UUPS upgrade on the\n///      live factory proxy without corrupting state.\ncontract DepositWalletFactory is\n    OwnableRoles,\n    Initializable,\n    UUPSUpgradeable,\n    DepositWalletFactoryErrors,\n    DepositWalletFactoryEvents\n{\n    /*--------------------------------------------------------------\n                                 STATE\n    --------------------------------------------------------------*/\n\n    /// @notice Legacy default wallet implementation pointer.\n    /// @dev Deprecated; not consulted by {deploy} or {deployLegacy}. Retained only to preserve\n    ///      slot 0 of the live factory proxy so this contract can be installed via UUPS upgrade\n    ///      in place.\n    address public implementation;\n\n    /// @notice The delay in seconds that must elapse after pausing before the owner can\n    ///         execute paused-only operations on a wallet.\n    uint256 public timelockDelay;\n\n    /// @notice Tracks which implementation addresses are authorized for legacy UUPS upgrades.\n    /// @dev Legacy-shape wallets gate their `upgrade` self-call on this mapping. Used during the\n    ///      migration window to authorize {BeaconForwarder} so existing UUPS wallets can opt into\n    ///      the beacon. Will be deprecated after the migration window closes.\n    mapping(address => bool) public authorizedImplementation;\n\n    /*--------------------------------------------------------------\n                              CONSTANTS\n    --------------------------------------------------------------*/\n\n    /// @notice The maximum allowed timelock delay (7 days).\n    uint256 public constant MAX_TIMELOCK_DELAY = 7 days;\n\n    /*--------------------------------------------------------------\n                              IMMUTABLES\n    --------------------------------------------------------------*/\n\n    /// @notice The beacon that resolves the implementation for beacon-shape wallets.\n    address public immutable BEACON;\n\n    /// @notice The implementation embedded in legacy-shape (ERC-1967, UUPS) wallets.\n    /// @dev Set to the live legacy DepositWallet implementation so {deployLegacy} reproduces the\n    ///      exact wallet addresses the pre-beacon factory deployed.\n    address public immutable LEGACY_IMPL;\n\n    /*--------------------------------------------------------------\n                              CONSTRUCTOR\n    --------------------------------------------------------------*/\n\n    /// @dev Sets the beacon and legacy implementation, then disables initializers on the\n    ///      implementation contract.\n    /// @param _beacon The beacon contract address for beacon-shape wallets.\n    /// @param _legacyImpl The legacy implementation address embedded in legacy-shape wallets.\n    constructor(address _beacon, address _legacyImpl) {\n        require(_beacon != address(0), Errors.ZeroAddress());\n        require(_legacyImpl != address(0), Errors.ZeroAddress());\n        BEACON = _beacon;\n        LEGACY_IMPL = _legacyImpl;\n        _disableInitializers();\n    }\n\n    /*--------------------------------------------------------------\n                              INITIALIZER\n    --------------------------------------------------------------*/\n\n    /// @notice Initializes the factory with an owner, admin, and timelock delay.\n    /// @param _owner The address to set as the factory owner.\n    /// @param _admin The address to grant the initial admin role.\n    /// @param _timelockDelay The initial timelock delay in seconds.\n    function initialize(address _owner, address _admin, uint256 _timelockDelay)\n        external\n        initializer\n    {\n        require(_owner != address(0), Errors.ZeroAddress());\n        require(_admin != address(0), Errors.ZeroAddress());\n        _initializeOwner(_owner);\n        _setRoles(_admin, _ROLE_0);\n        _setTimelockDelay(_timelockDelay);\n    }\n\n    /*--------------------------------------------------------------\n                               MODIFIERS\n    --------------------------------------------------------------*/\n\n    /// @dev Restricts access to addresses with the admin role (ROLE_0).\n    modifier onlyAdmin() {\n        require(hasAnyRole(msg.sender, _ROLE_0), OnlyAdmin());\n        _;\n    }\n\n    /// @dev Restricts access to addresses with the operator role (ROLE_1).\n    modifier onlyOperator() {\n        require(hasAnyRole(msg.sender, _ROLE_1), OnlyOperator());\n        _;\n    }\n\n    /// @dev Restricts access to addresses with the legacy-deployer role (ROLE_2).\n    modifier onlyLegacyDeployer() {\n        require(hasAnyRole(msg.sender, _ROLE_2), OnlyLegacyDeployer());\n        _;\n    }\n\n    /*--------------------------------------------------------------\n                                  VIEW\n    --------------------------------------------------------------*/\n\n    /// @notice Returns whether the given address has the admin role.\n    /// @param _admin The address to check.\n    /// @return True if the address is an admin.\n    function isAdmin(address _admin) external view returns (bool) {\n        return hasAnyRole(_admin, _ROLE_0);\n    }\n\n    /// @notice Returns whether the given address has the operator role.\n    /// @param _operator The address to check.\n    /// @return True if the address is an operator.\n    function isOperator(address _operator) external view returns (bool) {\n        return hasAnyRole(_operator, _ROLE_1);\n    }\n\n    /// @notice Returns whether the given address has the legacy-deployer role.\n    /// @param _legacyDeployer The address to check.\n    /// @return True if the address is a legacy deployer.\n    function isLegacyDeployer(address _legacyDeployer) external view returns (bool) {\n        return hasAnyRole(_legacyDeployer, _ROLE_2);\n    }\n\n    /// @notice Predicts the deterministic address of a wallet before deployment.\n    /// @dev Deprecated; retained for ABI compatibility. The first argument is ignored — wallets\n    ///      are now beacon proxies bound to {BEACON}. Prefer {predictWalletAddress(bytes32)}.\n    /// @param _id The unique identifier for the wallet.\n    /// @return The predicted wallet proxy address.\n    function predictWalletAddress(address, bytes32 _id) external view returns (address) {\n        return _predictWalletAddress(_id);\n    }\n\n    /// @notice Predicts the deterministic address of a beacon-proxy wallet before deployment.\n    /// @dev This returns the address derived from the beacon-proxy template. For the address of a\n    ///      legacy-shape (ERC-1967, UUPS) wallet, use {predictLegacyWalletAddress} — the two\n    ///      shapes live at different deterministic addresses because the proxy bytecode (and\n    ///      therefore the CREATE2 derivation) differs.\n    /// @param _id The unique identifier for the wallet.\n    /// @return The predicted beacon-proxy wallet address.\n    function predictWalletAddress(bytes32 _id) external view returns (address) {\n        return _predictWalletAddress(_id);\n    }\n\n    /// @notice Predicts the deterministic address of a legacy-shape (ERC-1967) wallet before\n    ///         deployment.\n    /// @dev This matches the address the pre-beacon factory assigned to a wallet with the same\n    ///      `_id` — including, on other chains, the address of the user's Polygon wallet —\n    ///      enabling cross-chain recovery at the identical address.\n    /// @param _id The unique identifier for the wallet.\n    /// @return The predicted legacy wallet address.\n    function predictLegacyWalletAddress(bytes32 _id) external view returns (address) {\n        bytes memory args = abi.encode(address(this), _id);\n\n        return LibClone.predictDeterministicAddressERC1967(\n            LEGACY_IMPL, args, keccak256(args), address(this)\n        );\n    }\n\n    /*--------------------------------------------------------------\n                             ONLY OPERATOR\n    --------------------------------------------------------------*/\n\n    /// @notice Deploys one or more beacon-shape deposit wallets with deterministic addresses.\n    /// @dev It is the operator's responsibility to ensure that each `_id` is unique.\n    ///      Duplicate IDs will cause the deployment to revert because the deterministic\n    ///      address is already occupied. Note: beacon-shape and legacy-shape wallets for the\n    ///      same `_id` live at DIFFERENT addresses (different proxy template), so they never\n    ///      collide; the operator must dedupe IDs across both shapes off-chain.\n    /// @param _owners The initial owner addresses for each wallet.\n    /// @param _ids The unique identifiers for each wallet.\n    function deploy(address[] calldata _owners, bytes32[] calldata _ids) external onlyOperator {\n        require(_owners.length == _ids.length, ArrayLengthMismatch());\n\n        // Fail closed: require both the beacon AND its resolved implementation to hold code.\n        // A beacon-proxy delegatecalls the beacon's resolved implementation, so checking only the\n        // beacon address would let a beacon resolving to a code-less implementation slip through,\n        // turning `initialize` into a silent no-op delegatecall and minting an ownerless wallet.\n        require(BEACON.code.length != 0, ImplementationNotDeployed());\n        require(IBeacon(BEACON).implementation().code.length != 0, ImplementationNotDeployed());\n\n        for (uint256 i; i < _owners.length; ++i) {\n            bytes memory args = abi.encode(address(this), _ids[i]);\n\n            address wallet =\n                LibClone.deployDeterministicERC1967BeaconProxy(BEACON, args, keccak256(args));\n\n            IDepositWallet(wallet).initialize(_owners[i]);\n\n            emit WalletDeployed(wallet, _owners[i], _ids[i], BEACON);\n        }\n    }\n\n    /// @notice Proxies batch execution to one or more wallets.\n    /// @dev Each batch is forwarded to its target wallet's `execute` function. Works for both\n    ///      wallet shapes (the `Batch` layout is identical across the legacy and current\n    ///      implementations).\n    /// @param _batches The batches to execute.\n    /// @param _signatures The corresponding signatures for each batch.\n    function proxy(Batch[] calldata _batches, bytes[] calldata _signatures) external onlyOperator {\n        require(_batches.length == _signatures.length, ArrayLengthMismatch());\n        for (uint256 i; i < _batches.length; ++i) {\n            IDepositWallet(_batches[i].wallet).execute(_batches[i], _signatures[i]);\n        }\n    }\n\n    /*--------------------------------------------------------------\n                          ONLY LEGACY DEPLOYER\n    --------------------------------------------------------------*/\n\n    /// @notice Deploys one or more legacy-shape (ERC-1967, UUPS) deposit wallets with\n    ///         deterministic addresses that match the pre-beacon factory's derivation.\n    /// @dev Restricted to the legacy-deployer role (ROLE_2), granted independently of the\n    ///      operator role. Used for ids whose legacy address has already been handed out, and for\n    ///      cross-chain recovery: a wallet deployed here lands at the same address the user's\n    ///      Polygon deposit wallet occupies. The resulting wallet runs {LEGACY_IMPL} (the V1\n    ///      implementation). See {deploy} for the ID-uniqueness and cross-shape notes.\n    /// @param _owners The initial owner addresses for each wallet.\n    /// @param _ids The unique identifiers for each wallet.\n    function deployLegacy(address[] calldata _owners, bytes32[] calldata _ids)\n        external\n        onlyLegacyDeployer\n    {\n        require(_owners.length == _ids.length, ArrayLengthMismatch());\n\n        // Fail closed: a code-less legacy implementation would mint ownerless wallets.\n        require(LEGACY_IMPL.code.length != 0, ImplementationNotDeployed());\n\n        for (uint256 i; i < _owners.length; ++i) {\n            bytes memory args = abi.encode(address(this), _ids[i]);\n\n            address wallet = LibClone.deployDeterministicERC1967(LEGACY_IMPL, args, keccak256(args));\n\n            IDepositWallet(wallet).initialize(_owners[i]);\n\n            emit WalletDeployed(wallet, _owners[i], _ids[i], LEGACY_IMPL);\n        }\n    }\n\n    /*--------------------------------------------------------------\n                               ONLY ADMIN\n    --------------------------------------------------------------*/\n\n    /// @notice Grants the operator role to an address.\n    /// @param _operator The address to grant the operator role.\n    function addOperator(address _operator) external onlyAdmin {\n        _grantRoles(_operator, _ROLE_1);\n    }\n\n    /// @notice Removes the operator role from an address.\n    /// @param _operator The address to remove the operator role from.\n    function removeOperator(address _operator) external onlyAdmin {\n        _removeRoles(_operator, _ROLE_1);\n    }\n\n    /// @notice Grants the legacy-deployer role to an address.\n    /// @param _legacyDeployer The address to grant the legacy-deployer role.\n    function addLegacyDeployer(address _legacyDeployer) external onlyAdmin {\n        _grantRoles(_legacyDeployer, _ROLE_2);\n    }\n\n    /// @notice Removes the legacy-deployer role from an address.\n    /// @param _legacyDeployer The address to remove the legacy-deployer role from.\n    function removeLegacyDeployer(address _legacyDeployer) external onlyAdmin {\n        _removeRoles(_legacyDeployer, _ROLE_2);\n    }\n\n    /// @notice Sets the timelock delay for paused wallet operations.\n    /// @param _timelockDelay The new timelock delay in seconds.\n    function setTimelockDelay(uint256 _timelockDelay) external onlyAdmin {\n        _setTimelockDelay(_timelockDelay);\n    }\n\n    /*--------------------------------------------------------------\n                               ONLY OWNER\n    --------------------------------------------------------------*/\n\n    /// @notice Grants the admin role to an address.\n    /// @param _admin The address to grant the admin role.\n    function addAdmin(address _admin) external onlyOwner {\n        _grantRoles(_admin, _ROLE_0);\n    }\n\n    /// @notice Removes the admin role from an address.\n    /// @param _admin The address to remove the admin role from.\n    function removeAdmin(address _admin) external onlyOwner {\n        _removeRoles(_admin, _ROLE_0);\n    }\n\n    /// @notice Sets the legacy slot-0 implementation pointer.\n    /// @dev Deprecated; retained for ABI compatibility. Has no effect on {deploy} (which uses\n    ///      {BEACON}) or {deployLegacy} (which uses {LEGACY_IMPL}).\n    /// @param _implementation The new default implementation address.\n    function setImplementation(address _implementation) external onlyOwner {\n        _setImplementation(_implementation);\n    }\n\n    /// @notice Authorizes an implementation address for legacy UUPS upgrades.\n    /// @dev Used during the migration window to authorize {BeaconForwarder}; will be deprecated\n    ///      after the migration window closes.\n    /// @param _implementation The implementation address to authorize.\n    function authorizeImplementation(address _implementation) external onlyOwner {\n        require(_implementation != address(0), Errors.ZeroAddress());\n        authorizedImplementation[_implementation] = true;\n\n        emit ImplementationAuthorized(_implementation);\n    }\n\n    /// @notice Removes an implementation address from the authorized set.\n    /// @dev Used during the migration window; will be deprecated after the window closes.\n    /// @param _implementation The implementation address to unauthorize.\n    function unauthorizeImplementation(address _implementation) external onlyOwner {\n        authorizedImplementation[_implementation] = false;\n\n        emit ImplementationUnauthorized(_implementation);\n    }\n\n    /*--------------------------------------------------------------\n                               INTERNAL\n    --------------------------------------------------------------*/\n\n    /// @dev Authorizes UUPS upgrades of the factory. Restricted to the owner.\n    function _authorizeUpgrade(address) internal override onlyOwner {}\n\n    /// @notice Writes the legacy slot-0 implementation pointer.\n    /// @dev Deprecated; retained for ABI compatibility. Slot 0 is no longer consulted by\n    ///      {deploy}.\n    /// @param _implementation The new default implementation address (must be authorized).\n    function _setImplementation(address _implementation) internal {\n        require(authorizedImplementation[_implementation], ImplementationNotAuthorized());\n        implementation = _implementation;\n\n        emit ImplementationSet(_implementation);\n    }\n\n    /// @notice Sets the timelock delay for paused wallet operations.\n    /// @param _timelockDelay The new timelock delay in seconds.\n    function _setTimelockDelay(uint256 _timelockDelay) internal {\n        require(_timelockDelay > 0 && _timelockDelay <= MAX_TIMELOCK_DELAY, InvalidTimelockDelay());\n        timelockDelay = _timelockDelay;\n\n        emit TimelockDelaySet(_timelockDelay);\n    }\n\n    /// @notice Computes the deterministic address of a wallet bound to {BEACON}.\n    /// @param _id The unique identifier for the wallet.\n    /// @return The predicted wallet proxy address.\n    function _predictWalletAddress(bytes32 _id) internal view returns (address) {\n        bytes memory args = abi.encode(address(this), _id);\n\n        return LibClone.predictDeterministicAddressERC1967BeaconProxy(\n            BEACON, args, keccak256(args), address(this)\n        );\n    }\n}\n"},"lib/solady/src/auth/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)\n///\n/// @dev Note:\n/// This implementation does NOT auto-initialize the owner to `msg.sender`.\n/// You MUST call the `_initializeOwner` in the constructor / initializer.\n///\n/// While the ownable portion follows\n/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,\n/// the nomenclature for the 2-step ownership handover may be unique to this codebase.\nabstract contract Ownable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The caller is not authorized to call the function.\n    error Unauthorized();\n\n    /// @dev The `newOwner` cannot be the zero address.\n    error NewOwnerIsZeroAddress();\n\n    /// @dev The `pendingOwner` does not have a valid handover request.\n    error NoHandoverRequest();\n\n    /// @dev Cannot double-initialize.\n    error AlreadyInitialized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.\n    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be\n    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),\n    /// despite it not being as lightweight as a single argument event.\n    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);\n\n    /// @dev An ownership handover to `pendingOwner` has been requested.\n    event OwnershipHandoverRequested(address indexed pendingOwner);\n\n    /// @dev The ownership handover to `pendingOwner` has been canceled.\n    event OwnershipHandoverCanceled(address indexed pendingOwner);\n\n    /// @dev `keccak256(bytes(\"OwnershipTransferred(address,address)\"))`.\n    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =\n        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverRequested(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =\n        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverCanceled(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =\n        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The owner slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_OWNER_SLOT_NOT\")))))`.\n    /// It is intentionally chosen to be a high value\n    /// to avoid collision with lower slots.\n    /// The choice of manual storage layout is to enable compatibility\n    /// with both regular and upgradeable contracts.\n    bytes32 internal constant _OWNER_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;\n\n    /// The ownership handover slot of `newOwner` is given by:\n    /// ```\n    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))\n    ///     let handoverSlot := keccak256(0x00, 0x20)\n    /// ```\n    /// It stores the expiry timestamp of the two-step ownership handover.\n    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.\n    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}\n\n    /// @dev Initializes the owner directly without authorization guard.\n    /// This function must be called upon initialization,\n    /// regardless of whether the contract is upgradeable or not.\n    /// This is to enable generalization to both regular and upgradeable contracts,\n    /// and to save gas in case the initial owner is not the caller.\n    /// For performance reasons, this function will not check if there\n    /// is an existing owner.\n    function _initializeOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                if sload(ownerSlot) {\n                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.\n                    revert(0x1c, 0x04)\n                }\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(_OWNER_SLOT, newOwner)\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        }\n    }\n\n    /// @dev Sets the owner directly without authorization guard.\n    function _setOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, newOwner)\n            }\n        }\n    }\n\n    /// @dev Throws if the sender is not the owner.\n    function _checkOwner() internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is not the stored owner, revert.\n            if iszero(eq(caller(), sload(_OWNER_SLOT))) {\n                mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Returns how long a two-step ownership handover is valid for in seconds.\n    /// Override to return a different value if needed.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {\n        return 48 * 3600;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Allows the owner to transfer the ownership to `newOwner`.\n    function transferOwnership(address newOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(shl(96, newOwner)) {\n                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _setOwner(newOwner);\n    }\n\n    /// @dev Allows the owner to renounce their ownership.\n    function renounceOwnership() public payable virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /// @dev Request a two-step ownership handover to the caller.\n    /// The request will automatically expire in 48 hours (172800 seconds) by default.\n    function requestOwnershipHandover() public payable virtual {\n        unchecked {\n            uint256 expires = block.timestamp + _ownershipHandoverValidFor();\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Compute and set the handover slot to `expires`.\n                mstore(0x0c, _HANDOVER_SLOT_SEED)\n                mstore(0x00, caller())\n                sstore(keccak256(0x0c, 0x20), expires)\n                // Emit the {OwnershipHandoverRequested} event.\n                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())\n            }\n        }\n    }\n\n    /// @dev Cancels the two-step ownership handover to the caller, if any.\n    function cancelOwnershipHandover() public payable virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x20), 0)\n            // Emit the {OwnershipHandoverCanceled} event.\n            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())\n        }\n    }\n\n    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.\n    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.\n    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            let handoverSlot := keccak256(0x0c, 0x20)\n            // If the handover does not exist, or has expired.\n            if gt(timestamp(), sload(handoverSlot)) {\n                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.\n                revert(0x1c, 0x04)\n            }\n            // Set the handover slot to 0.\n            sstore(handoverSlot, 0)\n        }\n        _setOwner(pendingOwner);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the owner of the contract.\n    function owner() public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_OWNER_SLOT)\n        }\n    }\n\n    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\n    function ownershipHandoverExpiresAt(address pendingOwner)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the handover slot.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            // Load the handover slot.\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by the owner.\n    modifier onlyOwner() virtual {\n        _checkOwner();\n        _;\n    }\n}\n"},"lib/solady/src/utils/LibClone.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Minimal proxy library.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibClone.sol)\n/// @author Minimal proxy by 0age (https://github.com/0age)\n/// @author Clones with immutable args by wighawag, zefram.eth, Saw-mon & Natalie\n/// (https://github.com/Saw-mon-and-Natalie/clones-with-immutable-args)\n/// @author Minimal ERC1967 proxy by jtriley-eth (https://github.com/jtriley-eth/minimum-viable-proxy)\n///\n/// @dev Minimal proxy:\n/// Although the sw0nt pattern saves 5 gas over the ERC1167 pattern during runtime,\n/// it is not supported out-of-the-box on Etherscan. Hence, we choose to use the 0age pattern,\n/// which saves 4 gas over the ERC1167 pattern during runtime, and has the smallest bytecode.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal proxy (PUSH0 variant):\n/// This is a new minimal proxy that uses the PUSH0 opcode introduced during Shanghai.\n/// It is optimized first for minimal runtime gas, then for minimal bytecode.\n/// The PUSH0 clone functions are intentionally postfixed with a jarring \"_PUSH0\" as\n/// many EVM chains may not support the PUSH0 opcode in the early months after Shanghai.\n/// Please use with caution.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Clones with immutable args (CWIA):\n/// The implementation of CWIA here does NOT append the immutable args into the calldata\n/// passed into delegatecall. It is simply an ERC1167 minimal proxy with the immutable arguments\n/// appended to the back of the runtime bytecode.\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n///\n/// @dev Minimal ERC1967 proxy:\n/// A minimal ERC1967 proxy, intended to be upgraded with UUPS.\n/// This is NOT the same as ERC1967Factory's transparent proxy, which includes admin logic.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal ERC1967 proxy with immutable args:\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n/// - Automatically verified on Etherscan.\n///\n/// @dev ERC1967I proxy:\n/// A variant of the minimal ERC1967 proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// `implementation` address. The returned implementation is guaranteed to be valid if the\n/// keccak256 of the proxy's code is equal to `ERC1967I_CODE_HASH`.\n///\n/// @dev ERC1967I proxy with immutable args:\n/// A variant of the minimal ERC1967 proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n///\n/// @dev Minimal ERC1967 beacon proxy:\n/// A minimal beacon proxy, intended to be upgraded with an upgradable beacon.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal ERC1967 beacon proxy with immutable args:\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n/// - Automatically verified on Etherscan.\n///\n/// @dev ERC1967I beacon proxy:\n/// A variant of the minimal ERC1967 beacon proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// `implementation` address. The returned implementation is guaranteed to be valid if the\n/// keccak256 of the proxy's code is equal to `ERC1967I_CODE_HASH`.\n///\n/// @dev ERC1967I proxy with immutable args:\n/// A variant of the minimal ERC1967 beacon proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// - Uses the identity precompile (0x4) to copy args during deployment.\nlibrary LibClone {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The keccak256 of deployed code for the clone proxy,\n    /// with the implementation set to `address(0)`.\n    bytes32 internal constant CLONE_CODE_HASH =\n        0x48db2cfdb2853fce0b464f1f93a1996469459df3ab6c812106074c4106a1eb1f;\n\n    /// @dev The keccak256 of deployed code for the PUSH0 proxy,\n    /// with the implementation set to `address(0)`.\n    bytes32 internal constant PUSH0_CLONE_CODE_HASH =\n        0x67bc6bde1b84d66e267c718ba44cf3928a615d29885537955cb43d44b3e789dc;\n\n    /// @dev The keccak256 of deployed code for the ERC-1167 CWIA proxy,\n    /// with the implementation set to `address(0)`.\n    bytes32 internal constant CWIA_CODE_HASH =\n        0x3cf92464268225a4513da40a34d967354684c32cd0edd67b5f668dfe3550e940;\n\n    /// @dev The keccak256 of the deployed code for the ERC1967 proxy.\n    bytes32 internal constant ERC1967_CODE_HASH =\n        0xaaa52c8cc8a0e3fd27ce756cc6b4e70c51423e9b597b11f32d3e49f8b1fc890d;\n\n    /// @dev The keccak256 of the deployed code for the ERC1967I proxy.\n    bytes32 internal constant ERC1967I_CODE_HASH =\n        0xce700223c0d4cea4583409accfc45adac4a093b3519998a9cbbe1504dadba6f7;\n\n    /// @dev The keccak256 of the deployed code for the ERC1967 beacon proxy.\n    bytes32 internal constant ERC1967_BEACON_PROXY_CODE_HASH =\n        0x14044459af17bc4f0f5aa2f658cb692add77d1302c29fe2aebab005eea9d1162;\n\n    /// @dev The keccak256 of the deployed code for the ERC1967 beacon proxy.\n    bytes32 internal constant ERC1967I_BEACON_PROXY_CODE_HASH =\n        0xf8c46d2793d5aa984eb827aeaba4b63aedcab80119212fce827309788735519a;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Unable to deploy the clone.\n    error DeploymentFailed();\n\n    /// @dev The salt must start with either the zero address or `by`.\n    error SaltDoesNotStartWith();\n\n    /// @dev The ETH transfer has failed.\n    error ETHTransferFailed();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  MINIMAL PROXY OPERATIONS                  */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a clone of `implementation`.\n    function clone(address implementation) internal returns (address instance) {\n        instance = clone(0, implementation);\n    }\n\n    /// @dev Deploys a clone of `implementation`.\n    /// Deposits `value` ETH during deployment.\n    function clone(uint256 value, address implementation) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * --------------------------------------------------------------------------+\n             * CREATION (9 bytes)                                                        |\n             * --------------------------------------------------------------------------|\n             * Opcode     | Mnemonic          | Stack     | Memory                       |\n             * --------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize     | r         |                              |\n             * 3d         | RETURNDATASIZE    | 0 r       |                              |\n             * 81         | DUP2              | r 0 r     |                              |\n             * 60 offset  | PUSH1 offset      | o r 0 r   |                              |\n             * 3d         | RETURNDATASIZE    | 0 o r 0 r |                              |\n             * 39         | CODECOPY          | 0 r       | [0..runSize): runtime code   |\n             * f3         | RETURN            |           | [0..runSize): runtime code   |\n             * --------------------------------------------------------------------------|\n             * RUNTIME (44 bytes)                                                        |\n             * --------------------------------------------------------------------------|\n             * Opcode  | Mnemonic       | Stack                  | Memory                |\n             * --------------------------------------------------------------------------|\n             *                                                                           |\n             * ::: keep some values in stack ::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d      | RETURNDATASIZE | 0                      |                       |\n             * 3d      | RETURNDATASIZE | 0 0                    |                       |\n             * 3d      | RETURNDATASIZE | 0 0 0                  |                       |\n             * 3d      | RETURNDATASIZE | 0 0 0 0                |                       |\n             *                                                                           |\n             * ::: copy calldata to memory ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36      | CALLDATASIZE   | cds 0 0 0 0            |                       |\n             * 3d      | RETURNDATASIZE | 0 cds 0 0 0 0          |                       |\n             * 3d      | RETURNDATASIZE | 0 0 cds 0 0 0 0        |                       |\n             * 37      | CALLDATACOPY   | 0 0 0 0                | [0..cds): calldata    |\n             *                                                                           |\n             * ::: delegate call to the implementation contract :::::::::::::::::::::::: |\n             * 36      | CALLDATASIZE   | cds 0 0 0 0            | [0..cds): calldata    |\n             * 3d      | RETURNDATASIZE | 0 cds 0 0 0 0          | [0..cds): calldata    |\n             * 73 addr | PUSH20 addr    | addr 0 cds 0 0 0 0     | [0..cds): calldata    |\n             * 5a      | GAS            | gas addr 0 cds 0 0 0 0 | [0..cds): calldata    |\n             * f4      | DELEGATECALL   | success 0 0            | [0..cds): calldata    |\n             *                                                                           |\n             * ::: copy return data to memory :::::::::::::::::::::::::::::::::::::::::: |\n             * 3d      | RETURNDATASIZE | rds success 0 0        | [0..cds): calldata    |\n             * 3d      | RETURNDATASIZE | rds rds success 0 0    | [0..cds): calldata    |\n             * 93      | SWAP4          | 0 rds success 0 rds    | [0..cds): calldata    |\n             * 80      | DUP1           | 0 0 rds success 0 rds  | [0..cds): calldata    |\n             * 3e      | RETURNDATACOPY | success 0 rds          | [0..rds): returndata  |\n             *                                                                           |\n             * 60 0x2a | PUSH1 0x2a     | 0x2a success 0 rds     | [0..rds): returndata  |\n             * 57      | JUMPI          | 0 rds                  | [0..rds): returndata  |\n             *                                                                           |\n             * ::: revert :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * fd      | REVERT         |                        | [0..rds): returndata  |\n             *                                                                           |\n             * ::: return :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b      | JUMPDEST       | 0 rds                  | [0..rds): returndata  |\n             * f3      | RETURN         |                        | [0..rds): returndata  |\n             * --------------------------------------------------------------------------+\n             */\n            mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n            mstore(0x14, implementation)\n            mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n            instance := create(value, 0x0c, 0x35)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation` with `salt`.\n    function cloneDeterministic(address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = cloneDeterministic(0, implementation, salt);\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation` with `salt`.\n    /// Deposits `value` ETH during deployment.\n    function cloneDeterministic(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n            mstore(0x14, implementation)\n            mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n            instance := create2(value, 0x0c, 0x35, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the clone of `implementation`.\n    function initCode(address implementation) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x40), 0x5af43d3d93803e602a57fd5bf30000000000000000000000)\n            mstore(add(c, 0x28), implementation)\n            mstore(add(c, 0x14), 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n            mstore(c, 0x35) // Store the length.\n            mstore(0x40, add(c, 0x60)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the clone of `implementation`.\n    function initCodeHash(address implementation) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n            mstore(0x14, implementation)\n            mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n            hash := keccak256(0x0c, 0x35)\n            mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the address of the clone of `implementation`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddress(address implementation, bytes32 salt, address deployer)\n        internal\n        pure\n        returns (address predicted)\n    {\n        bytes32 hash = initCodeHash(implementation);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*          MINIMAL PROXY OPERATIONS (PUSH0 VARIANT)          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a PUSH0 clone of `implementation`.\n    function clone_PUSH0(address implementation) internal returns (address instance) {\n        instance = clone_PUSH0(0, implementation);\n    }\n\n    /// @dev Deploys a PUSH0 clone of `implementation`.\n    /// Deposits `value` ETH during deployment.\n    function clone_PUSH0(uint256 value, address implementation)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * --------------------------------------------------------------------------+\n             * CREATION (9 bytes)                                                        |\n             * --------------------------------------------------------------------------|\n             * Opcode     | Mnemonic          | Stack     | Memory                       |\n             * --------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize     | r         |                              |\n             * 5f         | PUSH0             | 0 r       |                              |\n             * 81         | DUP2              | r 0 r     |                              |\n             * 60 offset  | PUSH1 offset      | o r 0 r   |                              |\n             * 5f         | PUSH0             | 0 o r 0 r |                              |\n             * 39         | CODECOPY          | 0 r       | [0..runSize): runtime code   |\n             * f3         | RETURN            |           | [0..runSize): runtime code   |\n             * --------------------------------------------------------------------------|\n             * RUNTIME (45 bytes)                                                        |\n             * --------------------------------------------------------------------------|\n             * Opcode  | Mnemonic       | Stack                  | Memory                |\n             * --------------------------------------------------------------------------|\n             *                                                                           |\n             * ::: keep some values in stack ::::::::::::::::::::::::::::::::::::::::::: |\n             * 5f      | PUSH0          | 0                      |                       |\n             * 5f      | PUSH0          | 0 0                    |                       |\n             *                                                                           |\n             * ::: copy calldata to memory ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36      | CALLDATASIZE   | cds 0 0                |                       |\n             * 5f      | PUSH0          | 0 cds 0 0              |                       |\n             * 5f      | PUSH0          | 0 0 cds 0 0            |                       |\n             * 37      | CALLDATACOPY   | 0 0                    | [0..cds): calldata    |\n             *                                                                           |\n             * ::: delegate call to the implementation contract :::::::::::::::::::::::: |\n             * 36      | CALLDATASIZE   | cds 0 0                | [0..cds): calldata    |\n             * 5f      | PUSH0          | 0 cds 0 0              | [0..cds): calldata    |\n             * 73 addr | PUSH20 addr    | addr 0 cds 0 0         | [0..cds): calldata    |\n             * 5a      | GAS            | gas addr 0 cds 0 0     | [0..cds): calldata    |\n             * f4      | DELEGATECALL   | success                | [0..cds): calldata    |\n             *                                                                           |\n             * ::: copy return data to memory :::::::::::::::::::::::::::::::::::::::::: |\n             * 3d      | RETURNDATASIZE | rds success            | [0..cds): calldata    |\n             * 5f      | PUSH0          | 0 rds success          | [0..cds): calldata    |\n             * 5f      | PUSH0          | 0 0 rds success        | [0..cds): calldata    |\n             * 3e      | RETURNDATACOPY | success                | [0..rds): returndata  |\n             *                                                                           |\n             * 60 0x29 | PUSH1 0x29     | 0x29 success           | [0..rds): returndata  |\n             * 57      | JUMPI          |                        | [0..rds): returndata  |\n             *                                                                           |\n             * ::: revert :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d      | RETURNDATASIZE | rds                    | [0..rds): returndata  |\n             * 5f      | PUSH0          | 0 rds                  | [0..rds): returndata  |\n             * fd      | REVERT         |                        | [0..rds): returndata  |\n             *                                                                           |\n             * ::: return :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b      | JUMPDEST       |                        | [0..rds): returndata  |\n             * 3d      | RETURNDATASIZE | rds                    | [0..rds): returndata  |\n             * 5f      | PUSH0          | 0 rds                  | [0..rds): returndata  |\n             * f3      | RETURN         |                        | [0..rds): returndata  |\n             * --------------------------------------------------------------------------+\n             */\n            mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n            mstore(0x14, implementation) // 20\n            mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n            instance := create(value, 0x0e, 0x36)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Deploys a deterministic PUSH0 clone of `implementation` with `salt`.\n    function cloneDeterministic_PUSH0(address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = cloneDeterministic_PUSH0(0, implementation, salt);\n    }\n\n    /// @dev Deploys a deterministic PUSH0 clone of `implementation` with `salt`.\n    /// Deposits `value` ETH during deployment.\n    function cloneDeterministic_PUSH0(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n            mstore(0x14, implementation) // 20\n            mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n            instance := create2(value, 0x0e, 0x36, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the PUSH0 clone of `implementation`.\n    function initCode_PUSH0(address implementation) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x40), 0x5af43d5f5f3e6029573d5ffd5b3d5ff300000000000000000000) // 16\n            mstore(add(c, 0x26), implementation) // 20\n            mstore(add(c, 0x12), 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n            mstore(c, 0x36) // Store the length.\n            mstore(0x40, add(c, 0x60)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the PUSH0 clone of `implementation`.\n    function initCodeHash_PUSH0(address implementation) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n            mstore(0x14, implementation) // 20\n            mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n            hash := keccak256(0x0e, 0x36)\n            mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the address of the PUSH0 clone of `implementation`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddress_PUSH0(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHash_PUSH0(implementation);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*           CLONES WITH IMMUTABLE ARGS OPERATIONS            */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a clone of `implementation` with immutable arguments encoded in `args`.\n    function clone(address implementation, bytes memory args) internal returns (address instance) {\n        instance = clone(0, implementation, args);\n    }\n\n    /// @dev Deploys a clone of `implementation` with immutable arguments encoded in `args`.\n    /// Deposits `value` ETH during deployment.\n    function clone(uint256 value, address implementation, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------+\n             * CREATION (10 bytes)                                                        |\n             * ---------------------------------------------------------------------------|\n             * Opcode     | Mnemonic          | Stack     | Memory                        |\n             * ---------------------------------------------------------------------------|\n             * 61 runSize | PUSH2 runSize     | r         |                               |\n             * 3d         | RETURNDATASIZE    | 0 r       |                               |\n             * 81         | DUP2              | r 0 r     |                               |\n             * 60 offset  | PUSH1 offset      | o r 0 r   |                               |\n             * 3d         | RETURNDATASIZE    | 0 o r 0 r |                               |\n             * 39         | CODECOPY          | 0 r       | [0..runSize): runtime code    |\n             * f3         | RETURN            |           | [0..runSize): runtime code    |\n             * ---------------------------------------------------------------------------|\n             * RUNTIME (45 bytes + extraLength)                                           |\n             * ---------------------------------------------------------------------------|\n             * Opcode   | Mnemonic       | Stack                  | Memory                |\n             * ---------------------------------------------------------------------------|\n             *                                                                            |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36       | CALLDATASIZE   | cds                    |                       |\n             * 3d       | RETURNDATASIZE | 0 cds                  |                       |\n             * 3d       | RETURNDATASIZE | 0 0 cds                |                       |\n             * 37       | CALLDATACOPY   |                        | [0..cds): calldata    |\n             *                                                                            |\n             * ::: delegate call to the implementation contract ::::::::::::::::::::::::: |\n             * 3d       | RETURNDATASIZE | 0                      | [0..cds): calldata    |\n             * 3d       | RETURNDATASIZE | 0 0                    | [0..cds): calldata    |\n             * 3d       | RETURNDATASIZE | 0 0 0                  | [0..cds): calldata    |\n             * 36       | CALLDATASIZE   | cds 0 0 0              | [0..cds): calldata    |\n             * 3d       | RETURNDATASIZE | 0 cds 0 0 0 0          | [0..cds): calldata    |\n             * 73 addr  | PUSH20 addr    | addr 0 cds 0 0 0 0     | [0..cds): calldata    |\n             * 5a       | GAS            | gas addr 0 cds 0 0 0 0 | [0..cds): calldata    |\n             * f4       | DELEGATECALL   | success 0 0            | [0..cds): calldata    |\n             *                                                                            |\n             * ::: copy return data to memory ::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d       | RETURNDATASIZE | rds success 0          | [0..cds): calldata    |\n             * 82       | DUP3           | 0 rds success 0         | [0..cds): calldata   |\n             * 80       | DUP1           | 0 0 rds success 0      | [0..cds): calldata    |\n             * 3e       | RETURNDATACOPY | success 0              | [0..rds): returndata  |\n             * 90       | SWAP1          | 0 success              | [0..rds): returndata  |\n             * 3d       | RETURNDATASIZE | rds 0 success          | [0..rds): returndata  |\n             * 91       | SWAP2          | success 0 rds          | [0..rds): returndata  |\n             *                                                                            |\n             * 60 0x2b  | PUSH1 0x2b     | 0x2b success 0 rds     | [0..rds): returndata  |\n             * 57       | JUMPI          | 0 rds                  | [0..rds): returndata  |\n             *                                                                            |\n             * ::: revert ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * fd       | REVERT         |                        | [0..rds): returndata  |\n             *                                                                            |\n             * ::: return ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b       | JUMPDEST       | 0 rds                  | [0..rds): returndata  |\n             * f3       | RETURN         |                        | [0..rds): returndata  |\n             * ---------------------------------------------------------------------------+\n             */\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n            mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            instance := create(value, add(m, add(0x0b, lt(n, 0xffd3))), add(n, 0x37))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation`\n    /// with immutable arguments encoded in `args` and `salt`.\n    function cloneDeterministic(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = cloneDeterministic(0, implementation, args, salt);\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation`\n    /// with immutable arguments encoded in `args` and `salt`.\n    function cloneDeterministic(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n            mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            instance := create2(value, add(m, add(0x0b, lt(n, 0xffd3))), add(n, 0x37), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation`\n    /// with immutable arguments encoded in `args` and `salt`.\n    /// This method does not revert if the clone has already been deployed.\n    function createDeterministicClone(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicClone(0, implementation, args, salt);\n    }\n\n    /// @dev Deploys a deterministic clone of `implementation`\n    /// with immutable arguments encoded in `args` and `salt`.\n    /// This method does not revert if the clone has already been deployed.\n    function createDeterministicClone(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n            mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(m, 0x14), implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            // forgefmt: disable-next-item\n            mstore(add(m, gt(n, 0xffd2)), add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(add(m, 0x0c), add(n, 0x37)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, add(m, 0x0c), add(n, 0x37), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the clone of `implementation`\n    /// using immutable arguments encoded in `args`.\n    function initCode(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffd2))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x57), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x37), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(c, 0x28), implementation)\n            mstore(add(c, 0x14), add(0x61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            mstore(c, add(0x37, n)) // Store the length.\n            mstore(add(c, add(n, 0x57)), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(c, add(n, 0x77))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the clone of `implementation`\n    /// using immutable arguments encoded in `args`.\n    function initCodeHash(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffd2))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x43), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0x61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n            hash := keccak256(add(m, 0x0c), add(n, 0x37))\n        }\n    }\n\n    /// @dev Returns the address of the clone of\n    /// `implementation` using immutable arguments encoded in `args`, with `salt`, by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddress(\n        address implementation,\n        bytes memory data,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHash(implementation, data);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnClone(instance, 0, 2 ** 256 - 1)`.\n    function argsOnClone(address instance) internal view returns (bytes memory args) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x2d))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x2d, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnClone(instance, start, 2 ** 256 - 1)`.\n    function argsOnClone(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x2d))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x0d), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the clone with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnClone(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x0d), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x2d)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*              MINIMAL ERC1967 PROXY OPERATIONS              */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // Note: The ERC1967 proxy here is intended to be upgraded with UUPS.\n    // This is NOT the same as ERC1967Factory's transparent proxy, which includes admin logic.\n\n    /// @dev Deploys a minimal ERC1967 proxy with `implementation`.\n    function deployERC1967(address implementation) internal returns (address instance) {\n        instance = deployERC1967(0, implementation);\n    }\n\n    /// @dev Deploys a minimal ERC1967 proxy with `implementation`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967(uint256 value, address implementation)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------------+\n             * CREATION (34 bytes)                                                              |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize  | r                |                                 |\n             * 3d         | RETURNDATASIZE | 0 r              |                                 |\n             * 81         | DUP2           | r 0 r            |                                 |\n             * 60 offset  | PUSH1 offset   | o r 0 r          |                                 |\n             * 3d         | RETURNDATASIZE | 0 o r 0 r        |                                 |\n             * 39         | CODECOPY       | 0 r              | [0..runSize): runtime code      |\n             * 73 impl    | PUSH20 impl    | impl 0 r         | [0..runSize): runtime code      |\n             * 60 slotPos | PUSH1 slotPos  | slotPos impl 0 r | [0..runSize): runtime code      |\n             * 51         | MLOAD          | slot impl 0 r    | [0..runSize): runtime code      |\n             * 55         | SSTORE         | 0 r              | [0..runSize): runtime code      |\n             * f3         | RETURN         |                  | [0..runSize): runtime code      |\n             * ---------------------------------------------------------------------------------|\n             * RUNTIME (61 bytes)                                                               |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             *                                                                                  |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 3d         | RETURNDATASIZE | 0 cds            |                                 |\n             * 3d         | RETURNDATASIZE | 0 0 cds          |                                 |\n             * 37         | CALLDATACOPY   |                  | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | 0                |                                 |\n             * 3d         | RETURNDATASIZE | 0 0              |                                 |\n             * 36         | CALLDATASIZE   | cds 0 0          | [0..calldatasize): calldata     |\n             * 3d         | RETURNDATASIZE | 0 cds 0 0        | [0..calldatasize): calldata     |\n             * 7f slot    | PUSH32 slot    | s 0 cds 0 0      | [0..calldatasize): calldata     |\n             * 54         | SLOAD          | i 0 cds 0 0      | [0..calldatasize): calldata     |\n             * 5a         | GAS            | g i 0 cds 0 0    | [0..calldatasize): calldata     |\n             * f4         | DELEGATECALL   | succ             | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds succ         | [0..calldatasize): calldata     |\n             * 60 0x00    | PUSH1 0x00     | 0 rds succ       | [0..calldatasize): calldata     |\n             * 80         | DUP1           | 0 0 rds succ     | [0..calldatasize): calldata     |\n             * 3e         | RETURNDATACOPY | succ             | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 60 0x38    | PUSH1 0x38     | dest succ        | [0..returndatasize): returndata |\n             * 57         | JUMPI          |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * fd         | REVERT         |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  | [0..returndatasize): returndata |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * f3         | RETURN         |                  | [0..returndatasize): returndata |\n             * ---------------------------------------------------------------------------------+\n             */\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x20, 0x6009)\n            mstore(0x1e, implementation)\n            mstore(0x0a, 0x603d3d8160223d3973)\n            instance := create(value, 0x21, 0x5f)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n    function deployDeterministicERC1967(address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967(0, implementation, salt);\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x20, 0x6009)\n            mstore(0x1e, implementation)\n            mstore(0x0a, 0x603d3d8160223d3973)\n            instance := create2(value, 0x21, 0x5f, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967(address implementation, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967(0, implementation, salt);\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x20, 0x6009)\n            mstore(0x1e, implementation)\n            mstore(0x0a, 0x603d3d8160223d3973)\n            // Compute and store the bytecode hash.\n            mstore(add(m, 0x35), keccak256(0x21, 0x5f))\n            mstore(m, shl(88, address()))\n            mstore8(m, 0xff) // Write the prefix.\n            mstore(add(m, 0x15), salt)\n            instance := keccak256(m, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, 0x21, 0x5f, salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the initialization code of the minimal ERC1967 proxy of `implementation`.\n    function initCodeERC1967(address implementation) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x60), 0x3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f300)\n            mstore(add(c, 0x40), 0x55f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076cc)\n            mstore(add(c, 0x20), or(shl(24, implementation), 0x600951))\n            mstore(add(c, 0x09), 0x603d3d8160223d3973)\n            mstore(c, 0x5f) // Store the length.\n            mstore(0x40, add(c, 0x80)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the minimal ERC1967 proxy of `implementation`.\n    function initCodeHashERC1967(address implementation) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x20, 0x6009)\n            mstore(0x1e, implementation)\n            mstore(0x0a, 0x603d3d8160223d3973)\n            hash := keccak256(0x21, 0x5f)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967 proxy of `implementation`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967(implementation);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*    MINIMAL ERC1967 PROXY WITH IMMUTABLE ARGS OPERATIONS    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a minimal ERC1967 proxy with `implementation` and `args`.\n    function deployERC1967(address implementation, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        instance = deployERC1967(0, implementation, args);\n    }\n\n    /// @dev Deploys a minimal ERC1967 proxy with `implementation` and `args`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967(uint256 value, address implementation, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n            mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x16, 0x6009)\n            mstore(0x14, implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            instance := create(value, m, add(n, 0x60))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n    function deployDeterministicERC1967(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967(0, implementation, args, salt);\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n            mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x16, 0x6009)\n            mstore(0x14, implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            instance := create2(value, m, add(n, 0x60), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967(0, implementation, args, salt);\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n            mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x16, 0x6009)\n            mstore(0x14, implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(m, add(n, 0x60)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, m, add(n, 0x60), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the minimal ERC1967 proxy of `implementation` and `args`.\n    function initCodeERC1967(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffc2))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x80), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x60), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(c, 0x40), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(add(c, 0x20), 0x6009)\n            mstore(add(c, 0x1e), implementation)\n            mstore(add(c, 0x0a), add(0x61003d3d8160233d3973, shl(56, n)))\n            mstore(c, add(n, 0x60)) // Store the length.\n            mstore(add(c, add(n, 0x80)), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(c, add(n, 0xa0))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the minimal ERC1967 proxy of `implementation` and `args`.\n    function initCodeHashERC1967(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffc2))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x60), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n            mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n            mstore(0x16, 0x6009)\n            mstore(0x14, implementation)\n            mstore(0x00, add(0x61003d3d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            hash := keccak256(m, add(n, 0x60))\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967 proxy of `implementation`, `args`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967(implementation, args);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnERC1967(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967(address instance) internal view returns (bytes memory args) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x3d))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x3d, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnERC1967(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x3d))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x1d), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the ERC1967 with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnERC1967(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x1d), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x3d)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                 ERC1967I PROXY OPERATIONS                  */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // Note: This proxy has a special code path that activates if `calldatasize() == 1`.\n    // This code path skips the delegatecall and directly returns the `implementation` address.\n    // The returned implementation is guaranteed to be valid if the keccak256 of the\n    // proxy's code is equal to `ERC1967I_CODE_HASH`.\n\n    /// @dev Deploys a ERC1967I proxy with `implementation`.\n    function deployERC1967I(address implementation) internal returns (address instance) {\n        instance = deployERC1967I(0, implementation);\n    }\n\n    /// @dev Deploys a ERC1967I proxy with `implementation`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967I(uint256 value, address implementation)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------------+\n             * CREATION (34 bytes)                                                              |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize  | r                |                                 |\n             * 3d         | RETURNDATASIZE | 0 r              |                                 |\n             * 81         | DUP2           | r 0 r            |                                 |\n             * 60 offset  | PUSH1 offset   | o r 0 r          |                                 |\n             * 3d         | RETURNDATASIZE | 0 o r 0 r        |                                 |\n             * 39         | CODECOPY       | 0 r              | [0..runSize): runtime code      |\n             * 73 impl    | PUSH20 impl    | impl 0 r         | [0..runSize): runtime code      |\n             * 60 slotPos | PUSH1 slotPos  | slotPos impl 0 r | [0..runSize): runtime code      |\n             * 51         | MLOAD          | slot impl 0 r    | [0..runSize): runtime code      |\n             * 55         | SSTORE         | 0 r              | [0..runSize): runtime code      |\n             * f3         | RETURN         |                  | [0..runSize): runtime code      |\n             * ---------------------------------------------------------------------------------|\n             * RUNTIME (82 bytes)                                                               |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             *                                                                                  |\n             * ::: check calldatasize ::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 58         | PC             | 1 cds            |                                 |\n             * 14         | EQ             | eqs              |                                 |\n             * 60 0x43    | PUSH1 0x43     | dest eqs         |                                 |\n             * 57         | JUMPI          |                  |                                 |\n             *                                                                                  |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 3d         | RETURNDATASIZE | 0 cds            |                                 |\n             * 3d         | RETURNDATASIZE | 0 0 cds          |                                 |\n             * 37         | CALLDATACOPY   |                  | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | 0                |                                 |\n             * 3d         | RETURNDATASIZE | 0 0              |                                 |\n             * 36         | CALLDATASIZE   | cds 0 0          | [0..calldatasize): calldata     |\n             * 3d         | RETURNDATASIZE | 0 cds 0 0        | [0..calldatasize): calldata     |\n             * 7f slot    | PUSH32 slot    | s 0 cds 0 0      | [0..calldatasize): calldata     |\n             * 54         | SLOAD          | i 0 cds 0 0      | [0..calldatasize): calldata     |\n             * 5a         | GAS            | g i 0 cds 0 0    | [0..calldatasize): calldata     |\n             * f4         | DELEGATECALL   | succ             | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds succ         | [0..calldatasize): calldata     |\n             * 60 0x00    | PUSH1 0x00     | 0 rds succ       | [0..calldatasize): calldata     |\n             * 80         | DUP1           | 0 0 rds succ     | [0..calldatasize): calldata     |\n             * 3e         | RETURNDATACOPY | succ             | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 60 0x3E    | PUSH1 0x3E     | dest succ        | [0..returndatasize): returndata |\n             * 57         | JUMPI          |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * fd         | REVERT         |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  | [0..returndatasize): returndata |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * f3         | RETURN         |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: implementation , return :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  |                                 |\n             * 60 0x20    | PUSH1 0x20     | 32               |                                 |\n             * 60 0x0F    | PUSH1 0x0F     | o 32             |                                 |\n             * 3d         | RETURNDATASIZE | 0 o 32           |                                 |\n             * 39         | CODECOPY       |                  | [0..32): implementation slot    |\n             * 3d         | RETURNDATASIZE | 0                | [0..32): implementation slot    |\n             * 51         | MLOAD          | slot             | [0..32): implementation slot    |\n             * 54         | SLOAD          | impl             | [0..32): implementation slot    |\n             * 3d         | RETURNDATASIZE | 0 impl           | [0..32): implementation slot    |\n             * 52         | MSTORE         |                  | [0..32): implementation address |\n             * 59         | MSIZE          | 32               | [0..32): implementation address |\n             * 3d         | RETURNDATASIZE | 0 32             | [0..32): implementation address |\n             * f3         | RETURN         |                  | [0..32): implementation address |\n             * ---------------------------------------------------------------------------------+\n             */\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n            instance := create(value, 0x0c, 0x74)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Deploys a deterministic ERC1967I proxy with `implementation` and `salt`.\n    function deployDeterministicERC1967I(address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967I(0, implementation, salt);\n    }\n\n    /// @dev Deploys a deterministic ERC1967I proxy with `implementation` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967I(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n            instance := create2(value, 0x0c, 0x74, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Creates a deterministic ERC1967I proxy with `implementation` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967I(address implementation, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967I(0, implementation, salt);\n    }\n\n    /// @dev Creates a deterministic ERC1967I proxy with `implementation` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967I(uint256 value, address implementation, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n            // Compute and store the bytecode hash.\n            mstore(add(m, 0x35), keccak256(0x0c, 0x74))\n            mstore(m, shl(88, address()))\n            mstore8(m, 0xff) // Write the prefix.\n            mstore(add(m, 0x15), salt)\n            instance := keccak256(m, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, 0x0c, 0x74, salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the initialization code of the ERC1967I proxy of `implementation`.\n    function initCodeERC1967I(address implementation) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x74), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(c, 0x54), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(c, 0x34), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(add(c, 0x1d), implementation)\n            mstore(add(c, 0x09), 0x60523d8160223d3973)\n            mstore(add(c, 0x94), 0)\n            mstore(c, 0x74) // Store the length.\n            mstore(0x40, add(c, 0xa0)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967I proxy of `implementation`.\n    function initCodeHashERC1967I(address implementation) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n            hash := keccak256(0x0c, 0x74)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967I proxy of `implementation`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967I(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967I(implementation);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*       ERC1967I PROXY WITH IMMUTABLE ARGS OPERATIONS        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a minimal ERC1967I proxy with `implementation` and `args`.\n    function deployERC1967I(address implementation, bytes memory args) internal returns (address) {\n        return deployERC1967I(0, implementation, args);\n    }\n\n    /// @dev Deploys a minimal ERC1967I proxy with `implementation` and `args`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967I(uint256 value, address implementation, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n\n            mstore(add(m, 0x6b), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(m, 0x4b), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(m, 0x2b), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0xfe6100523d8160233d3973, shl(56, n)))\n\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            instance := create(value, add(m, add(0x15, lt(n, 0xffae))), add(0x75, n))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic ERC1967I proxy with `implementation`, `args`, and `salt`.\n    function deployDeterministicERC1967I(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967I(0, implementation, args, salt);\n    }\n\n    /// @dev Deploys a deterministic ERC1967I proxy with `implementation`, `args`, and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967I(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n\n            mstore(add(m, 0x6b), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(m, 0x4b), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(m, 0x2b), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(add(m, 0x14), implementation)\n            mstore(m, add(0xfe6100523d8160233d3973, shl(56, n)))\n\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            instance := create2(value, add(m, add(0x15, lt(n, 0xffae))), add(0x75, n), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Creates a deterministic ERC1967I proxy with `implementation`, `args` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967I(address implementation, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967I(0, implementation, args, salt);\n    }\n\n    /// @dev Creates a deterministic ERC1967I proxy with `implementation`, `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967I(\n        uint256 value,\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x75), n))\n            mstore(add(m, 0x55), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(m, 0x35), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(m, 0x15), 0x5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x16, 0x600f)\n            mstore(0x14, implementation)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            mstore(gt(n, 0xffad), add(0xfe6100523d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(m, add(n, 0x75)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, m, add(0x75, n), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the ERC1967I proxy of `implementation` and `args`.\n    function initCodeERC1967I(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x95), i), mload(add(add(args, 0x20), i)))\n            }\n\n            mstore(add(c, 0x75), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(c, 0x55), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(c, 0x35), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(add(c, 0x1e), implementation)\n            mstore(add(c, 0x0a), add(0x6100523d8160233d3973, shl(56, n)))\n            mstore(add(c, add(n, 0x95)), 0)\n            mstore(c, add(0x75, n)) // Store the length.\n            mstore(0x40, add(c, add(n, 0xb5))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967I proxy of `implementation` and `args.\n    function initCodeHashERC1967I(address implementation, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x75), i), mload(add(add(args, 0x20), i)))\n            }\n\n            mstore(add(m, 0x55), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n            mstore(add(m, 0x35), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n            mstore(add(m, 0x15), 0x5155f3365814604357363d3d373d3d363d7f360894)\n            mstore(0x16, 0x600f)\n            mstore(0x14, implementation)\n            mstore(0x00, add(0x6100523d8160233d3973, shl(56, n)))\n            mstore(m, mload(0x16))\n            hash := keccak256(m, add(0x75, n))\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967I proxy of `implementation`, `args` with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967I(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967I(implementation, args);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnERC1967I(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967I(address instance) internal view returns (bytes memory args) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x52))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x52, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnERC1967I(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967I(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x52))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x32), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the ERC1967 with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnERC1967I(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x32), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x52)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                ERC1967 BOOTSTRAP OPERATIONS                */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // A bootstrap is a minimal UUPS implementation that allows an ERC1967 proxy\n    // pointing to it to be upgraded. The ERC1967 proxy can then be deployed to a\n    // deterministic address independent of the implementation:\n    // ```\n    //     address bootstrap = LibClone.erc1967Bootstrap();\n    //     address instance = LibClone.deployDeterministicERC1967(0, bootstrap, salt);\n    //     LibClone.bootstrapERC1967(bootstrap, implementation);\n    // ```\n\n    /// @dev Deploys the ERC1967 bootstrap if it has not been deployed.\n    function erc1967Bootstrap() internal returns (address) {\n        return erc1967Bootstrap(address(this));\n    }\n\n    /// @dev Deploys the ERC1967 bootstrap if it has not been deployed.\n    function erc1967Bootstrap(address authorizedUpgrader) internal returns (address bootstrap) {\n        bytes memory c = initCodeERC1967Bootstrap(authorizedUpgrader);\n        bootstrap = predictDeterministicAddress(keccak256(c), bytes32(0), address(this));\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(extcodesize(bootstrap)) {\n                if iszero(create2(0, add(c, 0x20), mload(c), 0)) {\n                    mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n    }\n\n    /// @dev Replaces the implementation at `instance`.\n    function bootstrapERC1967(address instance, address implementation) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, implementation)\n            if iszero(call(gas(), instance, 0, 0x0c, 0x14, codesize(), 0x00)) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Replaces the implementation at `instance`, and then call it with `data`.\n    function bootstrapERC1967AndCall(address instance, address implementation, bytes memory data)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let n := mload(data)\n            mstore(data, implementation)\n            if iszero(call(gas(), instance, 0, add(data, 0x0c), add(n, 0x14), codesize(), 0x00)) {\n                if iszero(returndatasize()) {\n                    mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                returndatacopy(mload(0x40), 0x00, returndatasize())\n                revert(mload(0x40), returndatasize())\n            }\n            mstore(data, n) // Restore the length of `data`.\n        }\n    }\n\n    /// @dev Returns the implementation address of the ERC1967 bootstrap for this contract.\n    function predictDeterministicAddressERC1967Bootstrap() internal view returns (address) {\n        return predictDeterministicAddressERC1967Bootstrap(address(this), address(this));\n    }\n\n    /// @dev Returns the implementation address of the ERC1967 bootstrap for this contract.\n    function predictDeterministicAddressERC1967Bootstrap(\n        address authorizedUpgrader,\n        address deployer\n    ) internal pure returns (address) {\n        bytes32 hash = initCodeHashERC1967Bootstrap(authorizedUpgrader);\n        return predictDeterministicAddress(hash, bytes32(0), deployer);\n    }\n\n    /// @dev Returns the initialization code of the ERC1967 bootstrap.\n    function initCodeERC1967Bootstrap(address authorizedUpgrader)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x80), 0x3d3560601c5af46047573d6000383e3d38fd0000000000000000000000000000)\n            mstore(add(c, 0x60), 0xa920a3ca505d382bbc55601436116049575b005b363d3d373d3d601436036014)\n            mstore(add(c, 0x40), 0x0338573d3560601c7f360894a13ba1a3210667c828492db98dca3e2076cc3735)\n            mstore(add(c, 0x20), authorizedUpgrader)\n            mstore(add(c, 0x0c), 0x606880600a3d393df3fe3373)\n            mstore(c, 0x72)\n            mstore(0x40, add(c, 0xa0))\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967 bootstrap.\n    function initCodeHashERC1967Bootstrap(address authorizedUpgrader)\n        internal\n        pure\n        returns (bytes32)\n    {\n        return keccak256(initCodeERC1967Bootstrap(authorizedUpgrader));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*          MINIMAL ERC1967 BEACON PROXY OPERATIONS           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // Note: If you use this proxy, you MUST make sure that the beacon is a\n    // valid ERC1967 beacon. This means that the beacon must always return a valid\n    // address upon a staticcall to `implementation()`, given sufficient gas.\n    // For performance, the deployment operations and the proxy assumes that the\n    // beacon is always valid and will NOT validate it.\n\n    /// @dev Deploys a minimal ERC1967 beacon proxy.\n    function deployERC1967BeaconProxy(address beacon) internal returns (address instance) {\n        instance = deployERC1967BeaconProxy(0, beacon);\n    }\n\n    /// @dev Deploys a minimal ERC1967 beacon proxy.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967BeaconProxy(uint256 value, address beacon)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------------+\n             * CREATION (34 bytes)                                                              |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize  | r                |                                 |\n             * 3d         | RETURNDATASIZE | 0 r              |                                 |\n             * 81         | DUP2           | r 0 r            |                                 |\n             * 60 offset  | PUSH1 offset   | o r 0 r          |                                 |\n             * 3d         | RETURNDATASIZE | 0 o r 0 r        |                                 |\n             * 39         | CODECOPY       | 0 r              | [0..runSize): runtime code      |\n             * 73 beac    | PUSH20 beac    | beac 0 r         | [0..runSize): runtime code      |\n             * 60 slotPos | PUSH1 slotPos  | slotPos beac 0 r | [0..runSize): runtime code      |\n             * 51         | MLOAD          | slot beac 0 r    | [0..runSize): runtime code      |\n             * 55         | SSTORE         | 0 r              | [0..runSize): runtime code      |\n             * f3         | RETURN         |                  | [0..runSize): runtime code      |\n             * ---------------------------------------------------------------------------------|\n             * RUNTIME (82 bytes)                                                               |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             *                                                                                  |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 3d         | RETURNDATASIZE | 0 cds            |                                 |\n             * 3d         | RETURNDATASIZE | 0 0 cds          |                                 |\n             * 37         | CALLDATACOPY   |                  | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | 0                |                                 |\n             * 3d         | RETURNDATASIZE | 0 0              |                                 |\n             * 36         | CALLDATASIZE   | cds 0 0          | [0..calldatasize): calldata     |\n             * 3d         | RETURNDATASIZE | 0 cds 0 0        | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ~~~~~~~ beacon staticcall sub procedure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 60 0x20       | PUSH1 0x20       | 32                          |                 |\n             * 36            | CALLDATASIZE     | cds 32                      |                 |\n             * 60 0x04       | PUSH1 0x04       | 4 cds 32                    |                 |\n             * 36            | CALLDATASIZE     | cds 4 cds 32                |                 |\n             * 63 0x5c60da1b | PUSH4 0x5c60da1b | 0x5c60da1b cds 4 cds 32     |                 |\n             * 60 0xe0       | PUSH1 0xe0       | 224 0x5c60da1b cds 4 cds 32 |                 |\n             * 1b            | SHL              | sel cds 4 cds 32            |                 |\n             * 36            | CALLDATASIZE     | cds sel cds 4 cds 32        |                 |\n             * 52            | MSTORE           | cds 4 cds 32                | sel             |\n             * 7f slot       | PUSH32 slot      | s cds 4 cds 32              | sel             |\n             * 54            | SLOAD            | beac cds 4 cds 32           | sel             |\n             * 5a            | GAS              | g beac cds 4 cds 32         | sel             |\n             * fa            | STATICCALL       | succ                        | impl            |\n             * 50            | POP              |                             | impl            |\n             * 36            | CALLDATASIZE     | cds                         | impl            |\n             * 51            | MLOAD            | impl                        | impl            |\n             * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 5a         | GAS            | g impl 0 cds 0 0 | [0..calldatasize): calldata     |\n             * f4         | DELEGATECALL   | succ             | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds succ         | [0..calldatasize): calldata     |\n             * 60 0x00    | PUSH1 0x00     | 0 rds succ       | [0..calldatasize): calldata     |\n             * 80         | DUP1           | 0 0 rds succ     | [0..calldatasize): calldata     |\n             * 3e         | RETURNDATACOPY | succ             | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 60 0x4d    | PUSH1 0x4d     | dest succ        | [0..returndatasize): returndata |\n             * 57         | JUMPI          |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * fd         | REVERT         |                  | [0..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  | [0..returndatasize): returndata |\n             * 3d         | RETURNDATASIZE | rds              | [0..returndatasize): returndata |\n             * 60 0x00    | PUSH1 0x00     | 0 rds            | [0..returndatasize): returndata |\n             * f3         | RETURN         |                  | [0..returndatasize): returndata |\n             * ---------------------------------------------------------------------------------+\n             */\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n            instance := create(value, 0x0c, 0x74)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `salt`.\n    function deployDeterministicERC1967BeaconProxy(address beacon, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967BeaconProxy(0, beacon, salt);\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967BeaconProxy(uint256 value, address beacon, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n            instance := create2(value, 0x0c, 0x74, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967BeaconProxy(address beacon, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967BeaconProxy(0, beacon, salt);\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967BeaconProxy(uint256 value, address beacon, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n            // Compute and store the bytecode hash.\n            mstore(add(m, 0x35), keccak256(0x0c, 0x74))\n            mstore(m, shl(88, address()))\n            mstore8(m, 0xff) // Write the prefix.\n            mstore(add(m, 0x15), salt)\n            instance := keccak256(m, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, 0x0c, 0x74, salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the initialization code of the minimal ERC1967 beacon proxy.\n    function initCodeERC1967BeaconProxy(address beacon) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x74), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(c, 0x54), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(c, 0x34), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(c, 0x1d), beacon)\n            mstore(add(c, 0x09), 0x60523d8160223d3973)\n            mstore(add(c, 0x94), 0)\n            mstore(c, 0x74) // Store the length.\n            mstore(0x40, add(c, 0xa0)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the minimal ERC1967 beacon proxy.\n    function initCodeHashERC1967BeaconProxy(address beacon) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n            hash := keccak256(0x0c, 0x74)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967 beacon proxy, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967BeaconProxy(\n        address beacon,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967BeaconProxy(beacon);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*    ERC1967 BEACON PROXY WITH IMMUTABLE ARGS OPERATIONS     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a minimal ERC1967 beacon proxy with `args`.\n    function deployERC1967BeaconProxy(address beacon, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        instance = deployERC1967BeaconProxy(0, beacon, args);\n    }\n\n    /// @dev Deploys a minimal ERC1967 beacon proxy with `args`.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967BeaconProxy(uint256 value, address beacon, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n            mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n            instance := create(value, add(m, 0x16), add(n, 0x75))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n    function deployDeterministicERC1967BeaconProxy(address beacon, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967BeaconProxy(0, beacon, args, salt);\n    }\n\n    /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967BeaconProxy(\n        uint256 value,\n        address beacon,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n            mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n            instance := create2(value, add(m, 0x16), add(n, 0x75), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967BeaconProxy(address beacon, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967BeaconProxy(0, beacon, args, salt);\n    }\n\n    /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967BeaconProxy(\n        uint256 value,\n        address beacon,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n            mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(add(m, 0x16), add(n, 0x75)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, add(m, 0x16), add(n, 0x75), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the minimal ERC1967 beacon proxy.\n    function initCodeERC1967BeaconProxy(address beacon, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x95), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x75), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(c, 0x55), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(c, 0x35), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(c, 0x1e), beacon)\n            mstore(add(c, 0x0a), add(0x6100523d8160233d3973, shl(56, n)))\n            mstore(c, add(n, 0x75)) // Store the length.\n            mstore(add(c, add(n, 0x95)), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(c, add(n, 0xb5))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the minimal ERC1967 beacon proxy with `args`.\n    function initCodeHashERC1967BeaconProxy(address beacon, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x8b), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n            mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n            mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n            mstore(add(m, 0x14), beacon)\n            mstore(m, add(0x6100523d8160233d3973, shl(56, n)))\n            hash := keccak256(add(m, 0x16), add(n, 0x75))\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967 beacon proxy with `args`, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967BeaconProxy(\n        address beacon,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967BeaconProxy(beacon, args);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnERC1967BeaconProxy(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967BeaconProxy(address instance) internal view returns (bytes memory args) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x52))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x52, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnERC1967BeaconProxy(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967BeaconProxy(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x52))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x32), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the ERC1967 beacon proxy with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnERC1967BeaconProxy(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x32), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x52)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*              ERC1967I BEACON PROXY OPERATIONS              */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // Note: This proxy has a special code path that activates if `calldatasize() == 1`.\n    // This code path skips the delegatecall and directly returns the `implementation` address.\n    // The returned implementation is guaranteed to be valid if the keccak256 of the\n    // proxy's code is equal to `ERC1967_BEACON_PROXY_CODE_HASH`.\n    //\n    // If you use this proxy, you MUST make sure that the beacon is a\n    // valid ERC1967 beacon. This means that the beacon must always return a valid\n    // address upon a staticcall to `implementation()`, given sufficient gas.\n    // For performance, the deployment operations and the proxy assumes that the\n    // beacon is always valid and will NOT validate it.\n\n    /// @dev Deploys a ERC1967I beacon proxy.\n    function deployERC1967IBeaconProxy(address beacon) internal returns (address instance) {\n        instance = deployERC1967IBeaconProxy(0, beacon);\n    }\n\n    /// @dev Deploys a ERC1967I beacon proxy.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967IBeaconProxy(uint256 value, address beacon)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            /**\n             * ---------------------------------------------------------------------------------+\n             * CREATION (34 bytes)                                                              |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             * 60 runSize | PUSH1 runSize  | r                |                                 |\n             * 3d         | RETURNDATASIZE | 0 r              |                                 |\n             * 81         | DUP2           | r 0 r            |                                 |\n             * 60 offset  | PUSH1 offset   | o r 0 r          |                                 |\n             * 3d         | RETURNDATASIZE | 0 o r 0 r        |                                 |\n             * 39         | CODECOPY       | 0 r              | [0..runSize): runtime code      |\n             * 73 beac    | PUSH20 beac    | beac 0 r         | [0..runSize): runtime code      |\n             * 60 slotPos | PUSH1 slotPos  | slotPos beac 0 r | [0..runSize): runtime code      |\n             * 51         | MLOAD          | slot beac 0 r    | [0..runSize): runtime code      |\n             * 55         | SSTORE         | 0 r              | [0..runSize): runtime code      |\n             * f3         | RETURN         |                  | [0..runSize): runtime code      |\n             * ---------------------------------------------------------------------------------|\n             * RUNTIME (87 bytes)                                                               |\n             * ---------------------------------------------------------------------------------|\n             * Opcode     | Mnemonic       | Stack            | Memory                          |\n             * ---------------------------------------------------------------------------------|\n             *                                                                                  |\n             * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 36         | CALLDATASIZE   | cds              |                                 |\n             * 3d         | RETURNDATASIZE | 0 cds            |                                 |\n             * 3d         | RETURNDATASIZE | 0 0 cds          |                                 |\n             * 37         | CALLDATACOPY   |                  | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | 0                |                                 |\n             * 3d         | RETURNDATASIZE | 0 0              |                                 |\n             * 36         | CALLDATASIZE   | cds 0 0          | [0..calldatasize): calldata     |\n             * 3d         | RETURNDATASIZE | 0 cds 0 0        | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ~~~~~~~ beacon staticcall sub procedure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 60 0x20       | PUSH1 0x20       | 32                          |                 |\n             * 36            | CALLDATASIZE     | cds 32                      |                 |\n             * 60 0x04       | PUSH1 0x04       | 4 cds 32                    |                 |\n             * 36            | CALLDATASIZE     | cds 4 cds 32                |                 |\n             * 63 0x5c60da1b | PUSH4 0x5c60da1b | 0x5c60da1b cds 4 cds 32     |                 |\n             * 60 0xe0       | PUSH1 0xe0       | 224 0x5c60da1b cds 4 cds 32 |                 |\n             * 1b            | SHL              | sel cds 4 cds 32            |                 |\n             * 36            | CALLDATASIZE     | cds sel cds 4 cds 32        |                 |\n             * 52            | MSTORE           | cds 4 cds 32                | sel             |\n             * 7f slot       | PUSH32 slot      | s cds 4 cds 32              | sel             |\n             * 54            | SLOAD            | beac cds 4 cds 32           | sel             |\n             * 5a            | GAS              | g beac cds 4 cds 32         | sel             |\n             * fa            | STATICCALL       | succ                        | impl            |\n             * ~~~~~~ check calldatasize ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 36            | CALLDATASIZE     | cds succ                    |                 |\n             * 14            | EQ               |                             | impl            |\n             * 60 0x52       | PUSH1 0x52       |                             | impl            |\n             * 57            | JUMPI            |                             | impl            |\n             * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 36            | CALLDATASIZE     | cds                         | impl            |\n             * 51            | MLOAD            | impl                        | impl            |\n             * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n             * 5a         | GAS            | g impl 0 cds 0 0 | [0..calldatasize): calldata     |\n             * f4         | DELEGATECALL   | succ             | [0..calldatasize): calldata     |\n             *                                                                                  |\n             * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds succ         | [0..calldatasize): calldata     |\n             * 60 0x00    | PUSH1 0x00     | 0 rds succ       | [0..calldatasize): calldata     |\n             * 60 0x01    | PUSH1 0x01     | 1 0 rds succ     | [0..calldatasize): calldata     |\n             * 3e         | RETURNDATACOPY | succ             | [1..returndatasize): returndata |\n             *                                                                                  |\n             * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n             * 60 0x52    | PUSH1 0x52     | dest succ        | [1..returndatasize): returndata |\n             * 57         | JUMPI          |                  | [1..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n             * 3d         | RETURNDATASIZE | rds              | [1..returndatasize): returndata |\n             * 60 0x01    | PUSH1 0x01     | 1 rds            | [1..returndatasize): returndata |\n             * fd         | REVERT         |                  | [1..returndatasize): returndata |\n             *                                                                                  |\n             * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n             * 5b         | JUMPDEST       |                  | [1..returndatasize): returndata |\n             * 3d         | RETURNDATASIZE | rds              | [1..returndatasize): returndata |\n             * 60 0x01    | PUSH1 0x01     | 1 rds            | [1..returndatasize): returndata |\n             * f3         | RETURN         |                  | [1..returndatasize): returndata |\n             * ---------------------------------------------------------------------------------+\n             */\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n            instance := create(value, 0x07, 0x79)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Deploys a deterministic ERC1967I beacon proxy with `salt`.\n    function deployDeterministicERC1967IBeaconProxy(address beacon, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967IBeaconProxy(0, beacon, salt);\n    }\n\n    /// @dev Deploys a deterministic ERC1967I beacon proxy with `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967IBeaconProxy(uint256 value, address beacon, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n            instance := create2(value, 0x07, 0x79, salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Creates a deterministic ERC1967I beacon proxy with `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967IBeaconProxy(address beacon, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967IBeaconProxy(0, beacon, salt);\n    }\n\n    /// @dev Creates a deterministic ERC1967I beacon proxy with `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967IBeaconProxy(uint256 value, address beacon, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n            // Compute and store the bytecode hash.\n            mstore(add(m, 0x35), keccak256(0x07, 0x79))\n            mstore(m, shl(88, address()))\n            mstore8(m, 0xff) // Write the prefix.\n            mstore(add(m, 0x15), salt)\n            instance := keccak256(m, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, 0x07, 0x79, salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the initialization code of the ERC1967I beacon proxy.\n    function initCodeERC1967IBeaconProxy(address beacon) internal pure returns (bytes memory c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            mstore(add(c, 0x79), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(c, 0x59), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(c, 0x39), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(c, 0x1d), beacon)\n            mstore(add(c, 0x09), 0x60573d8160223d3973)\n            mstore(add(c, 0x99), 0)\n            mstore(c, 0x79) // Store the length.\n            mstore(0x40, add(c, 0xa0)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967I beacon proxy.\n    function initCodeHashERC1967IBeaconProxy(address beacon) internal pure returns (bytes32 hash) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n            hash := keccak256(0x07, 0x79)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero slot.\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967I beacon proxy, with `salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967IBeaconProxy(\n        address beacon,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967IBeaconProxy(beacon);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*    ERC1967I BEACON PROXY WITH IMMUTABLE ARGS OPERATIONS    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Deploys a ERC1967I beacon proxy with `args.\n    function deployERC1967IBeaconProxy(address beacon, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        instance = deployERC1967IBeaconProxy(0, beacon, args);\n    }\n\n    /// @dev Deploys a ERC1967I beacon proxy with `args.\n    /// Deposits `value` ETH during deployment.\n    function deployERC1967IBeaconProxy(uint256 value, address beacon, bytes memory args)\n        internal\n        returns (address instance)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n            mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n            instance := create(value, add(m, 0x16), add(n, 0x7a))\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Deploys a deterministic ERC1967I beacon proxy with `args` and `salt`.\n    function deployDeterministicERC1967IBeaconProxy(address beacon, bytes memory args, bytes32 salt)\n        internal\n        returns (address instance)\n    {\n        instance = deployDeterministicERC1967IBeaconProxy(0, beacon, args, salt);\n    }\n\n    /// @dev Deploys a deterministic ERC1967I beacon proxy with `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    function deployDeterministicERC1967IBeaconProxy(\n        uint256 value,\n        address beacon,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n            mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n            instance := create2(value, add(m, 0x16), add(n, 0x7a), salt)\n            if iszero(instance) {\n                mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Creates a deterministic ERC1967I beacon proxy with `args` and `salt`.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967IBeaconProxy(address beacon, bytes memory args, bytes32 salt)\n        internal\n        returns (bool alreadyDeployed, address instance)\n    {\n        return createDeterministicERC1967IBeaconProxy(0, beacon, args, salt);\n    }\n\n    /// @dev Creates a deterministic ERC1967I beacon proxy with `args` and `salt`.\n    /// Deposits `value` ETH during deployment.\n    /// Note: This method is intended for use in ERC4337 factories,\n    /// which are expected to NOT revert if the proxy is already deployed.\n    function createDeterministicERC1967IBeaconProxy(\n        uint256 value,\n        address beacon,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (bool alreadyDeployed, address instance) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(args)\n            pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n            mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(m, 0x14), beacon)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, keccak256(add(m, 0x16), add(n, 0x7a)))\n            mstore(0x01, shl(96, address()))\n            mstore(0x15, salt)\n            instance := keccak256(0x00, 0x55)\n            for {} 1 {} {\n                if iszero(extcodesize(instance)) {\n                    instance := create2(value, add(m, 0x16), add(n, 0x7a), salt)\n                    if iszero(instance) {\n                        mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n                        revert(0x1c, 0x04)\n                    }\n                    break\n                }\n                alreadyDeployed := 1\n                if iszero(value) { break }\n                if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                break\n            }\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the initialization code of the ERC1967I beacon proxy with `args`.\n    function initCodeERC1967IBeaconProxy(address beacon, bytes memory args)\n        internal\n        pure\n        returns (bytes memory c)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            c := mload(0x40)\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffa8))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x9a), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x7a), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(c, 0x5a), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(c, 0x3a), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(c, 0x1e), beacon)\n            mstore(add(c, 0x0a), add(0x6100573d8160233d3973, shl(56, n)))\n            mstore(add(c, add(n, 0x9a)), 0)\n            mstore(c, add(n, 0x7a)) // Store the length.\n            mstore(0x40, add(c, add(n, 0xba))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the initialization code hash of the ERC1967I beacon proxy with `args`.\n    function initCodeHashERC1967IBeaconProxy(address beacon, bytes memory args)\n        internal\n        pure\n        returns (bytes32 hash)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let c := mload(0x40) // Cache the free memory pointer.\n            let n := mload(args)\n            // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n            returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffa8))\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(c, 0x90), i), mload(add(add(args, 0x20), i)))\n            }\n            mstore(add(c, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n            mstore(add(c, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n            mstore(add(c, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n            mstore(add(c, 0x14), beacon)\n            mstore(c, add(0x6100573d8160233d3973, shl(56, n)))\n            hash := keccak256(add(c, 0x16), add(n, 0x7a))\n        }\n    }\n\n    /// @dev Returns the address of the ERC1967I beacon proxy, with  `args` and salt` by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddressERC1967IBeaconProxy(\n        address beacon,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes32 hash = initCodeHashERC1967IBeaconProxy(beacon, args);\n        predicted = predictDeterministicAddress(hash, salt, deployer);\n    }\n\n    /// @dev Equivalent to `argsOnERC1967IBeaconProxy(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967IBeaconProxy(address instance)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x57))) // Store the length.\n            extcodecopy(instance, add(args, 0x20), 0x57, add(mload(args), 0x20))\n            mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n        }\n    }\n\n    /// @dev Equivalent to `argsOnERC1967IBeaconProxy(instance, start, 2 ** 256 - 1)`.\n    function argsOnERC1967IBeaconProxy(address instance, uint256 start)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            let n := and(0xffffffffff, sub(extcodesize(instance), 0x57))\n            let l := sub(n, and(0xffffff, mul(lt(start, n), start)))\n            extcodecopy(instance, args, add(start, 0x37), add(l, 0x40))\n            mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n            mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n    /// `start` and `end` will be clamped to the range `[0, args.length]`.\n    /// The `instance` MUST be deployed via the ERC1967I beacon proxy with immutable args functions.\n    /// Otherwise, the behavior is undefined.\n    /// Out-of-gas reverts if `instance` does not have any code.\n    function argsOnERC1967IBeaconProxy(address instance, uint256 start, uint256 end)\n        internal\n        view\n        returns (bytes memory args)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            args := mload(0x40)\n            if iszero(lt(end, 0xffff)) { end := 0xffff }\n            let d := mul(sub(end, start), lt(start, end))\n            extcodecopy(instance, args, add(start, 0x37), add(d, 0x20))\n            if iszero(and(0xff, mload(add(args, d)))) {\n                let n := sub(extcodesize(instance), 0x57)\n                returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n                d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n            }\n            mstore(args, d) // Store the length.\n            mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n            mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      OTHER OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns `address(0)` if the implementation address cannot be determined.\n    function implementationOf(address instance) internal view returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            for { extcodecopy(instance, 0x00, 0x00, 0x57) } 1 {} {\n                if mload(0x2d) {\n                    // ERC1967I and ERC1967IBeaconProxy detection.\n                    if or(\n                        eq(keccak256(0x00, 0x52), ERC1967I_CODE_HASH),\n                        eq(keccak256(0x00, 0x57), ERC1967I_BEACON_PROXY_CODE_HASH)\n                    ) {\n                        pop(staticcall(gas(), instance, 0x00, 0x01, 0x00, 0x20))\n                        result := mload(0x0c)\n                        break\n                    }\n                }\n                // 0age clone detection.\n                result := mload(0x0b)\n                codecopy(0x0b, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n                if iszero(xor(keccak256(0x00, 0x2c), CLONE_CODE_HASH)) { break }\n                mstore(0x0b, result) // Restore the zeroized memory.\n                // CWIA detection.\n                result := mload(0x0a)\n                codecopy(0x0a, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n                if iszero(xor(keccak256(0x00, 0x2d), CWIA_CODE_HASH)) { break }\n                mstore(0x0a, result) // Restore the zeroized memory.\n                // PUSH0 clone detection.\n                result := mload(0x09)\n                codecopy(0x09, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n                result := shr(xor(keccak256(0x00, 0x2d), PUSH0_CLONE_CODE_HASH), result)\n                break\n            }\n            result := shr(96, result)\n            mstore(0x37, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Returns the address when a contract with initialization code hash,\n    /// `hash`, is deployed with `salt`, by `deployer`.\n    /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n    function predictDeterministicAddress(bytes32 hash, bytes32 salt, address deployer)\n        internal\n        pure\n        returns (address predicted)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and store the bytecode hash.\n            mstore8(0x00, 0xff) // Write the prefix.\n            mstore(0x35, hash)\n            mstore(0x01, shl(96, deployer))\n            mstore(0x15, salt)\n            predicted := keccak256(0x00, 0x55)\n            mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n        }\n    }\n\n    /// @dev Requires that `salt` starts with either the zero address or `by`.\n    function checkStartsWith(bytes32 salt, address by) internal pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the salt does not start with the zero address or `by`.\n            if iszero(or(iszero(shr(96, salt)), eq(shr(96, shl(96, by)), shr(96, salt)))) {\n                mstore(0x00, 0x0c4549ef) // `SaltDoesNotStartWith()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Returns the `bytes32` at `offset` in `args`, without any bounds checks.\n    /// To load an address, you can use `address(bytes20(argLoad(args, offset)))`.\n    function argLoad(bytes memory args, uint256 offset) internal pure returns (bytes32 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := mload(add(add(args, 0x20), offset))\n        }\n    }\n}\n"},"src/interfaces/IDepositWallet.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.13;\n\nimport {Batch} from \"@deposit-wallet/src/libraries/WalletLib.sol\";\n\n/// @title IDepositWallet\n/// @author Polymarket\n/// @notice Interface for the DepositWallet proxy contract.\ninterface IDepositWallet {\n    /*--------------------------------------------------------------\n                             INITIALIZER\n    --------------------------------------------------------------*/\n\n    /// @notice Initializes the wallet with a designated owner.\n    /// @param _owner The address to set as the wallet owner.\n    function initialize(address _owner) external;\n\n    /*--------------------------------------------------------------\n                                  VIEW\n    --------------------------------------------------------------*/\n\n    /// @notice Returns the wallet's current execution nonce.\n    /// @return The current nonce.\n    function nonce() external view returns (uint256);\n\n    /// @notice Returns the timestamp at which the wallet was paused.\n    /// @return The paused timestamp, or zero if not paused.\n    function paused() external view returns (uint256);\n\n    /// @notice Returns the timestamp until which a session signer is authorized.\n    /// @param _signer The session signer address to query.\n    /// @return The authorization expiry timestamp, or zero if not authorized.\n    function sessionSignerAuthorizedUntil(address _signer) external view returns (uint256);\n\n    /// @notice Returns a passkey session signer's public key and authorization expiry.\n    function passkeySessionSigner(bytes32 _passkeyId)\n        external\n        view\n        returns (bytes32 x, bytes32 y, uint256 validUntil);\n\n    /// @notice Returns the unique identifier assigned to this wallet at deployment.\n    /// @return The wallet ID decoded from the proxy's immutable args.\n    function id() external view returns (bytes32);\n\n    /// @notice Returns the factory contract that deployed this wallet.\n    /// @return The factory address decoded from the proxy's immutable args.\n    function factory() external view returns (address);\n\n    /// @notice Returns the current owner of the wallet.\n    /// @return The owner address.\n    function owner() external view returns (address);\n\n    /// @notice Returns the pending owner awaiting handover completion.\n    /// @return The pending owner address, or `address(0)` if none.\n    function pendingOwner() external view returns (address);\n\n    /// @notice Returns the deadline by which the pending owner must complete the handover.\n    /// @return The acceptance-deadline timestamp, or zero if no handover is pending.\n    function pendingOwnerDeadline() external view returns (uint256);\n\n    /// @notice Returns the per-handover nonce embedded in the EIP-712 signature.\n    /// @return The current handover nonce.\n    function pendingOwnerNonce() external view returns (uint256);\n\n    /// @notice Returns a stable magic identifying this contract as a `DepositWallet`.\n    /// @return The wallet identity magic.\n    function walletInterfaceId() external pure returns (bytes32);\n\n    /*--------------------------------------------------------------\n                             ONLY FACTORY\n    --------------------------------------------------------------*/\n\n    /// @notice Executes a signed batch of calls through the factory.\n    /// @dev Validates the batch (non-empty, correct wallet, nonce, deadline), verifies the EIP-712\n    ///      signature against the owner or an authorized session signer, then executes each call\n    ///      sequentially. Session signers are prevented from calling the wallet itself.\n    /// @param _batch The batch containing the target wallet, nonce, deadline, and calls.\n    /// @param _signature The EIP-712 signature authorizing the batch (owner or session signer).\n    function execute(Batch calldata _batch, bytes calldata _signature) external;\n\n    /*--------------------------------------------------------------\n                               ONLY SELF\n    --------------------------------------------------------------*/\n\n    /// @notice Authorizes a session signer until the specified timestamp.\n    /// @dev Can only be invoked via batch execution (self-call).\n    /// @param _sessionSigner The address to authorize as a session signer.\n    /// @param _validUntil The timestamp until which the session signer is valid.\n    function authorizeSessionSigner(address _sessionSigner, uint256 _validUntil) external;\n\n    /// @notice Revokes a session signer's authorization.\n    /// @dev Can only be invoked via batch execution (self-call).\n    /// @param _sessionSigner The session signer address to revoke.\n    function revokeSessionSigner(address _sessionSigner) external;\n\n    /// @notice Authorizes a P-256 passkey as a session signer.\n    function authorizePasskeySessionSigner(bytes32 _x, bytes32 _y, uint256 _validUntil) external;\n\n    /// @notice Revokes a passkey session signer.\n    function revokePasskeySessionSigner(bytes32 _passkeyId) external;\n\n    /// @notice Initiates a two-step ownership transfer to a new owner.\n    /// @dev Can only be invoked via batch execution (self-call). Records the on-chain deadline\n    ///      and bumps the per-handover nonce, invalidating any previously issued handover\n    ///      signature.\n    /// @param _newOwner The proposed new owner, distinct from the current owner and this wallet.\n    /// @param _deadline The timestamp by which the pending owner must complete the handover.\n    function transferOwnership(address _newOwner, uint256 _deadline) external;\n\n    /// @notice Cancels any pending ownership handover.\n    /// @dev Can only be invoked via batch execution (self-call).\n    function cancelOwnershipHandover() external;\n\n    /*--------------------------------------------------------------\n                           OWNERSHIP HANDOVER\n    --------------------------------------------------------------*/\n\n    /// @notice Completes a pending ownership transfer.\n    /// @dev Permissionless — anyone may submit, but the pending owner must have signed an\n    ///      EIP-712 `OwnershipHandover(newOwner, nonce)` message using the current\n    ///      {pendingOwnerNonce}, and the on-chain {pendingOwnerDeadline} must not have elapsed.\n    /// @param _signature The EIP-712 signature from the pending owner.\n    function completeOwnershipHandover(bytes calldata _signature) external;\n\n    /*--------------------------------------------------------------\n                               ONLY OWNER\n    --------------------------------------------------------------*/\n\n    /// @notice Pauses the wallet, recording the current timestamp.\n    /// @dev After pausing, the owner must wait for the timelock delay before calling\n    ///      paused-only functions (e.g., withdrawals, revocations).\n    function pause() external;\n\n    /// @notice Unpauses the wallet.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    function unpause() external;\n\n    /// @notice Withdraws native tokens from the wallet.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _to The recipient address.\n    /// @param _amount The amount of native tokens to withdraw.\n    function withdrawNative(address _to, uint256 _amount) external;\n\n    /// @notice Withdraws ERC-20 tokens from the wallet.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _token The ERC-20 token address.\n    /// @param _to The recipient address.\n    /// @param _amount The amount of tokens to withdraw.\n    function withdrawERC20(address _token, address _to, uint256 _amount) external;\n\n    /// @notice Batch-withdraws ERC-1155 tokens from the wallet.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _token The ERC-1155 token address.\n    /// @param _to The recipient address.\n    /// @param _ids The token IDs to withdraw.\n    /// @param _amounts The amounts for each token ID.\n    function withdrawERC1155(\n        address _token,\n        address _to,\n        uint256[] calldata _ids,\n        uint256[] calldata _amounts\n    ) external;\n\n    /// @notice Revokes an ERC-20 allowance by setting it to zero.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _token The ERC-20 token address.\n    /// @param _spender The spender whose allowance is revoked.\n    function revokeAllowance(address _token, address _spender) external;\n\n    /// @notice Revokes an ERC-1155 operator approval.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _token The ERC-1155 token address.\n    /// @param _operator The operator whose approval is revoked.\n    function revokeApprovalForAll(address _token, address _operator) external;\n\n    /// @notice Emergency revocation of a session signer by the owner.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    /// @param _sessionSigner The session signer to revoke.\n    function revokeSessionSignerEmergency(address _sessionSigner) external;\n\n    /// @notice Emergency revocation of a passkey session signer by the owner.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    function revokePasskeySessionSignerEmergency(bytes32 _passkeyId) external;\n\n    /// @notice Opts the wallet out of beacon upgrades, pinning it to the current default\n    ///         implementation.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    function optOut() external;\n\n    /// @notice Clears the wallet's beacon-upgrade pin, rejoining the upgrade cohort.\n    /// @dev Requires the wallet to be paused and the timelock delay to have elapsed.\n    function optIn() external;\n\n    /*--------------------------------------------------------------\n                                ERC1271\n    --------------------------------------------------------------*/\n\n    /// @notice Validates a signature against the wallet owner or an authorized session signer.\n    /// @param _hash The hash that was signed.\n    /// @param _signature The signature to validate (may contain a session signer wrapper).\n    /// @return result `ERC1271_MAGIC_VALUE` if the signature is valid, otherwise a non-magic\n    /// value.\n    function isValidSignature(bytes32 _hash, bytes calldata _signature)\n        external\n        view\n        returns (bytes4 result);\n}\n"},"lib/solady/src/auth/OwnableRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/// @notice Simple single owner and multiroles authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/OwnableRoles.sol)\n///\n/// @dev Note:\n/// This implementation does NOT auto-initialize the owner to `msg.sender`.\n/// You MUST call the `_initializeOwner` in the constructor / initializer.\n///\n/// While the ownable portion follows\n/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,\n/// the nomenclature for the 2-step ownership handover may be unique to this codebase.\nabstract contract OwnableRoles is Ownable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The `user`'s roles is updated to `roles`.\n    /// Each bit of `roles` represents whether the role is set.\n    event RolesUpdated(address indexed user, uint256 indexed roles);\n\n    /// @dev `keccak256(bytes(\"RolesUpdated(address,uint256)\"))`.\n    uint256 private constant _ROLES_UPDATED_EVENT_SIGNATURE =\n        0x715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe26;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The role slot of `user` is given by:\n    /// ```\n    ///     mstore(0x00, or(shl(96, user), _ROLE_SLOT_SEED))\n    ///     let roleSlot := keccak256(0x00, 0x20)\n    /// ```\n    /// This automatically ignores the upper bits of the `user` in case\n    /// they are not clean, as well as keep the `keccak256` under 32-bytes.\n    ///\n    /// Note: This is equivalent to `uint32(bytes4(keccak256(\"_OWNER_SLOT_NOT\")))`.\n    uint256 private constant _ROLE_SLOT_SEED = 0x8b78c6d8;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Overwrite the roles directly without authorization guard.\n    function _setRoles(address user, uint256 roles) internal virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, user)\n            // Store the new value.\n            sstore(keccak256(0x0c, 0x20), roles)\n            // Emit the {RolesUpdated} event.\n            log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), roles)\n        }\n    }\n\n    /// @dev Updates the roles directly without authorization guard.\n    /// If `on` is true, each set bit of `roles` will be turned on,\n    /// otherwise, each set bit of `roles` will be turned off.\n    function _updateRoles(address user, uint256 roles, bool on) internal virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, user)\n            let roleSlot := keccak256(0x0c, 0x20)\n            // Load the current value.\n            let current := sload(roleSlot)\n            // Compute the updated roles if `on` is true.\n            let updated := or(current, roles)\n            // Compute the updated roles if `on` is false.\n            // Use `and` to compute the intersection of `current` and `roles`,\n            // `xor` it with `current` to flip the bits in the intersection.\n            if iszero(on) { updated := xor(current, and(current, roles)) }\n            // Then, store the new value.\n            sstore(roleSlot, updated)\n            // Emit the {RolesUpdated} event.\n            log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), updated)\n        }\n    }\n\n    /// @dev Grants the roles directly without authorization guard.\n    /// Each bit of `roles` represents the role to turn on.\n    function _grantRoles(address user, uint256 roles) internal virtual {\n        _updateRoles(user, roles, true);\n    }\n\n    /// @dev Removes the roles directly without authorization guard.\n    /// Each bit of `roles` represents the role to turn off.\n    function _removeRoles(address user, uint256 roles) internal virtual {\n        _updateRoles(user, roles, false);\n    }\n\n    /// @dev Throws if the sender does not have any of the `roles`.\n    function _checkRoles(uint256 roles) internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the role slot.\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, caller())\n            // Load the stored value, and if the `and` intersection\n            // of the value and `roles` is zero, revert.\n            if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {\n                mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Throws if the sender is not the owner,\n    /// and does not have any of the `roles`.\n    /// Checks for ownership first, then lazily checks for roles.\n    function _checkOwnerOrRoles(uint256 roles) internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is not the stored owner.\n            // Note: `_ROLE_SLOT_SEED` is equal to `_OWNER_SLOT_NOT`.\n            if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {\n                // Compute the role slot.\n                mstore(0x0c, _ROLE_SLOT_SEED)\n                mstore(0x00, caller())\n                // Load the stored value, and if the `and` intersection\n                // of the value and `roles` is zero, revert.\n                if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {\n                    mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n    }\n\n    /// @dev Throws if the sender does not have any of the `roles`,\n    /// and is not the owner.\n    /// Checks for roles first, then lazily checks for ownership.\n    function _checkRolesOrOwner(uint256 roles) internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the role slot.\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, caller())\n            // Load the stored value, and if the `and` intersection\n            // of the value and `roles` is zero, revert.\n            if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {\n                // If the caller is not the stored owner.\n                // Note: `_ROLE_SLOT_SEED` is equal to `_OWNER_SLOT_NOT`.\n                if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {\n                    mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n    }\n\n    /// @dev Convenience function to return a `roles` bitmap from an array of `ordinals`.\n    /// This is meant for frontends like Etherscan, and is therefore not fully optimized.\n    /// Not recommended to be called on-chain.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _rolesFromOrdinals(uint8[] memory ordinals) internal pure returns (uint256 roles) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            for { let i := shl(5, mload(ordinals)) } i { i := sub(i, 0x20) } {\n                // We don't need to mask the values of `ordinals`, as Solidity\n                // cleans dirty upper bits when storing variables into memory.\n                roles := or(shl(mload(add(ordinals, i)), 1), roles)\n            }\n        }\n    }\n\n    /// @dev Convenience function to return an array of `ordinals` from the `roles` bitmap.\n    /// This is meant for frontends like Etherscan, and is therefore not fully optimized.\n    /// Not recommended to be called on-chain.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _ordinalsFromRoles(uint256 roles) internal pure returns (uint8[] memory ordinals) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Grab the pointer to the free memory.\n            ordinals := mload(0x40)\n            let ptr := add(ordinals, 0x20)\n            let o := 0\n            // The absence of lookup tables, De Bruijn, etc., here is intentional for\n            // smaller bytecode, as this function is not meant to be called on-chain.\n            for { let t := roles } 1 {} {\n                mstore(ptr, o)\n                // `shr` 5 is equivalent to multiplying by 0x20.\n                // Push back into the ordinals array if the bit is set.\n                ptr := add(ptr, shl(5, and(t, 1)))\n                o := add(o, 1)\n                t := shr(o, roles)\n                if iszero(t) { break }\n            }\n            // Store the length of `ordinals`.\n            mstore(ordinals, shr(5, sub(ptr, add(ordinals, 0x20))))\n            // Allocate the memory.\n            mstore(0x40, ptr)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Allows the owner to grant `user` `roles`.\n    /// If the `user` already has a role, then it will be an no-op for the role.\n    function grantRoles(address user, uint256 roles) public payable virtual onlyOwner {\n        _grantRoles(user, roles);\n    }\n\n    /// @dev Allows the owner to remove `user` `roles`.\n    /// If the `user` does not have a role, then it will be an no-op for the role.\n    function revokeRoles(address user, uint256 roles) public payable virtual onlyOwner {\n        _removeRoles(user, roles);\n    }\n\n    /// @dev Allow the caller to remove their own roles.\n    /// If the caller does not have a role, then it will be an no-op for the role.\n    function renounceRoles(uint256 roles) public payable virtual {\n        _removeRoles(msg.sender, roles);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the roles of `user`.\n    function rolesOf(address user) public view virtual returns (uint256 roles) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the role slot.\n            mstore(0x0c, _ROLE_SLOT_SEED)\n            mstore(0x00, user)\n            // Load the stored value.\n            roles := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Returns whether `user` has any of `roles`.\n    function hasAnyRole(address user, uint256 roles) public view virtual returns (bool) {\n        return rolesOf(user) & roles != 0;\n    }\n\n    /// @dev Returns whether `user` has all of `roles`.\n    function hasAllRoles(address user, uint256 roles) public view virtual returns (bool) {\n        return rolesOf(user) & roles == roles;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by an account with `roles`.\n    modifier onlyRoles(uint256 roles) virtual {\n        _checkRoles(roles);\n        _;\n    }\n\n    /// @dev Marks a function as only callable by the owner or by an account\n    /// with `roles`. Checks for ownership first, then lazily checks for roles.\n    modifier onlyOwnerOrRoles(uint256 roles) virtual {\n        _checkOwnerOrRoles(roles);\n        _;\n    }\n\n    /// @dev Marks a function as only callable by an account with `roles`\n    /// or the owner. Checks for roles first, then lazily checks for ownership.\n    modifier onlyRolesOrOwner(uint256 roles) virtual {\n        _checkRolesOrOwner(roles);\n        _;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ROLE CONSTANTS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // IYKYK\n\n    uint256 internal constant _ROLE_0 = 1 << 0;\n    uint256 internal constant _ROLE_1 = 1 << 1;\n    uint256 internal constant _ROLE_2 = 1 << 2;\n    uint256 internal constant _ROLE_3 = 1 << 3;\n    uint256 internal constant _ROLE_4 = 1 << 4;\n    uint256 internal constant _ROLE_5 = 1 << 5;\n    uint256 internal constant _ROLE_6 = 1 << 6;\n    uint256 internal constant _ROLE_7 = 1 << 7;\n    uint256 internal constant _ROLE_8 = 1 << 8;\n    uint256 internal constant _ROLE_9 = 1 << 9;\n    uint256 internal constant _ROLE_10 = 1 << 10;\n    uint256 internal constant _ROLE_11 = 1 << 11;\n    uint256 internal constant _ROLE_12 = 1 << 12;\n    uint256 internal constant _ROLE_13 = 1 << 13;\n    uint256 internal constant _ROLE_14 = 1 << 14;\n    uint256 internal constant _ROLE_15 = 1 << 15;\n    uint256 internal constant _ROLE_16 = 1 << 16;\n    uint256 internal constant _ROLE_17 = 1 << 17;\n    uint256 internal constant _ROLE_18 = 1 << 18;\n    uint256 internal constant _ROLE_19 = 1 << 19;\n    uint256 internal constant _ROLE_20 = 1 << 20;\n    uint256 internal constant _ROLE_21 = 1 << 21;\n    uint256 internal constant _ROLE_22 = 1 << 22;\n    uint256 internal constant _ROLE_23 = 1 << 23;\n    uint256 internal constant _ROLE_24 = 1 << 24;\n    uint256 internal constant _ROLE_25 = 1 << 25;\n    uint256 internal constant _ROLE_26 = 1 << 26;\n    uint256 internal constant _ROLE_27 = 1 << 27;\n    uint256 internal constant _ROLE_28 = 1 << 28;\n    uint256 internal constant _ROLE_29 = 1 << 29;\n    uint256 internal constant _ROLE_30 = 1 << 30;\n    uint256 internal constant _ROLE_31 = 1 << 31;\n    uint256 internal constant _ROLE_32 = 1 << 32;\n    uint256 internal constant _ROLE_33 = 1 << 33;\n    uint256 internal constant _ROLE_34 = 1 << 34;\n    uint256 internal constant _ROLE_35 = 1 << 35;\n    uint256 internal constant _ROLE_36 = 1 << 36;\n    uint256 internal constant _ROLE_37 = 1 << 37;\n    uint256 internal constant _ROLE_38 = 1 << 38;\n    uint256 internal constant _ROLE_39 = 1 << 39;\n    uint256 internal constant _ROLE_40 = 1 << 40;\n    uint256 internal constant _ROLE_41 = 1 << 41;\n    uint256 internal constant _ROLE_42 = 1 << 42;\n    uint256 internal constant _ROLE_43 = 1 << 43;\n    uint256 internal constant _ROLE_44 = 1 << 44;\n    uint256 internal constant _ROLE_45 = 1 << 45;\n    uint256 internal constant _ROLE_46 = 1 << 46;\n    uint256 internal constant _ROLE_47 = 1 << 47;\n    uint256 internal constant _ROLE_48 = 1 << 48;\n    uint256 internal constant _ROLE_49 = 1 << 49;\n    uint256 internal constant _ROLE_50 = 1 << 50;\n    uint256 internal constant _ROLE_51 = 1 << 51;\n    uint256 internal constant _ROLE_52 = 1 << 52;\n    uint256 internal constant _ROLE_53 = 1 << 53;\n    uint256 internal constant _ROLE_54 = 1 << 54;\n    uint256 internal constant _ROLE_55 = 1 << 55;\n    uint256 internal constant _ROLE_56 = 1 << 56;\n    uint256 internal constant _ROLE_57 = 1 << 57;\n    uint256 internal constant _ROLE_58 = 1 << 58;\n    uint256 internal constant _ROLE_59 = 1 << 59;\n    uint256 internal constant _ROLE_60 = 1 << 60;\n    uint256 internal constant _ROLE_61 = 1 << 61;\n    uint256 internal constant _ROLE_62 = 1 << 62;\n    uint256 internal constant _ROLE_63 = 1 << 63;\n    uint256 internal constant _ROLE_64 = 1 << 64;\n    uint256 internal constant _ROLE_65 = 1 << 65;\n    uint256 internal constant _ROLE_66 = 1 << 66;\n    uint256 internal constant _ROLE_67 = 1 << 67;\n    uint256 internal constant _ROLE_68 = 1 << 68;\n    uint256 internal constant _ROLE_69 = 1 << 69;\n    uint256 internal constant _ROLE_70 = 1 << 70;\n    uint256 internal constant _ROLE_71 = 1 << 71;\n    uint256 internal constant _ROLE_72 = 1 << 72;\n    uint256 internal constant _ROLE_73 = 1 << 73;\n    uint256 internal constant _ROLE_74 = 1 << 74;\n    uint256 internal constant _ROLE_75 = 1 << 75;\n    uint256 internal constant _ROLE_76 = 1 << 76;\n    uint256 internal constant _ROLE_77 = 1 << 77;\n    uint256 internal constant _ROLE_78 = 1 << 78;\n    uint256 internal constant _ROLE_79 = 1 << 79;\n    uint256 internal constant _ROLE_80 = 1 << 80;\n    uint256 internal constant _ROLE_81 = 1 << 81;\n    uint256 internal constant _ROLE_82 = 1 << 82;\n    uint256 internal constant _ROLE_83 = 1 << 83;\n    uint256 internal constant _ROLE_84 = 1 << 84;\n    uint256 internal constant _ROLE_85 = 1 << 85;\n    uint256 internal constant _ROLE_86 = 1 << 86;\n    uint256 internal constant _ROLE_87 = 1 << 87;\n    uint256 internal constant _ROLE_88 = 1 << 88;\n    uint256 internal constant _ROLE_89 = 1 << 89;\n    uint256 internal constant _ROLE_90 = 1 << 90;\n    uint256 internal constant _ROLE_91 = 1 << 91;\n    uint256 internal constant _ROLE_92 = 1 << 92;\n    uint256 internal constant _ROLE_93 = 1 << 93;\n    uint256 internal constant _ROLE_94 = 1 << 94;\n    uint256 internal constant _ROLE_95 = 1 << 95;\n    uint256 internal constant _ROLE_96 = 1 << 96;\n    uint256 internal constant _ROLE_97 = 1 << 97;\n    uint256 internal constant _ROLE_98 = 1 << 98;\n    uint256 internal constant _ROLE_99 = 1 << 99;\n    uint256 internal constant _ROLE_100 = 1 << 100;\n    uint256 internal constant _ROLE_101 = 1 << 101;\n    uint256 internal constant _ROLE_102 = 1 << 102;\n    uint256 internal constant _ROLE_103 = 1 << 103;\n    uint256 internal constant _ROLE_104 = 1 << 104;\n    uint256 internal constant _ROLE_105 = 1 << 105;\n    uint256 internal constant _ROLE_106 = 1 << 106;\n    uint256 internal constant _ROLE_107 = 1 << 107;\n    uint256 internal constant _ROLE_108 = 1 << 108;\n    uint256 internal constant _ROLE_109 = 1 << 109;\n    uint256 internal constant _ROLE_110 = 1 << 110;\n    uint256 internal constant _ROLE_111 = 1 << 111;\n    uint256 internal constant _ROLE_112 = 1 << 112;\n    uint256 internal constant _ROLE_113 = 1 << 113;\n    uint256 internal constant _ROLE_114 = 1 << 114;\n    uint256 internal constant _ROLE_115 = 1 << 115;\n    uint256 internal constant _ROLE_116 = 1 << 116;\n    uint256 internal constant _ROLE_117 = 1 << 117;\n    uint256 internal constant _ROLE_118 = 1 << 118;\n    uint256 internal constant _ROLE_119 = 1 << 119;\n    uint256 internal constant _ROLE_120 = 1 << 120;\n    uint256 internal constant _ROLE_121 = 1 << 121;\n    uint256 internal constant _ROLE_122 = 1 << 122;\n    uint256 internal constant _ROLE_123 = 1 << 123;\n    uint256 internal constant _ROLE_124 = 1 << 124;\n    uint256 internal constant _ROLE_125 = 1 << 125;\n    uint256 internal constant _ROLE_126 = 1 << 126;\n    uint256 internal constant _ROLE_127 = 1 << 127;\n    uint256 internal constant _ROLE_128 = 1 << 128;\n    uint256 internal constant _ROLE_129 = 1 << 129;\n    uint256 internal constant _ROLE_130 = 1 << 130;\n    uint256 internal constant _ROLE_131 = 1 << 131;\n    uint256 internal constant _ROLE_132 = 1 << 132;\n    uint256 internal constant _ROLE_133 = 1 << 133;\n    uint256 internal constant _ROLE_134 = 1 << 134;\n    uint256 internal constant _ROLE_135 = 1 << 135;\n    uint256 internal constant _ROLE_136 = 1 << 136;\n    uint256 internal constant _ROLE_137 = 1 << 137;\n    uint256 internal constant _ROLE_138 = 1 << 138;\n    uint256 internal constant _ROLE_139 = 1 << 139;\n    uint256 internal constant _ROLE_140 = 1 << 140;\n    uint256 internal constant _ROLE_141 = 1 << 141;\n    uint256 internal constant _ROLE_142 = 1 << 142;\n    uint256 internal constant _ROLE_143 = 1 << 143;\n    uint256 internal constant _ROLE_144 = 1 << 144;\n    uint256 internal constant _ROLE_145 = 1 << 145;\n    uint256 internal constant _ROLE_146 = 1 << 146;\n    uint256 internal constant _ROLE_147 = 1 << 147;\n    uint256 internal constant _ROLE_148 = 1 << 148;\n    uint256 internal constant _ROLE_149 = 1 << 149;\n    uint256 internal constant _ROLE_150 = 1 << 150;\n    uint256 internal constant _ROLE_151 = 1 << 151;\n    uint256 internal constant _ROLE_152 = 1 << 152;\n    uint256 internal constant _ROLE_153 = 1 << 153;\n    uint256 internal constant _ROLE_154 = 1 << 154;\n    uint256 internal constant _ROLE_155 = 1 << 155;\n    uint256 internal constant _ROLE_156 = 1 << 156;\n    uint256 internal constant _ROLE_157 = 1 << 157;\n    uint256 internal constant _ROLE_158 = 1 << 158;\n    uint256 internal constant _ROLE_159 = 1 << 159;\n    uint256 internal constant _ROLE_160 = 1 << 160;\n    uint256 internal constant _ROLE_161 = 1 << 161;\n    uint256 internal constant _ROLE_162 = 1 << 162;\n    uint256 internal constant _ROLE_163 = 1 << 163;\n    uint256 internal constant _ROLE_164 = 1 << 164;\n    uint256 internal constant _ROLE_165 = 1 << 165;\n    uint256 internal constant _ROLE_166 = 1 << 166;\n    uint256 internal constant _ROLE_167 = 1 << 167;\n    uint256 internal constant _ROLE_168 = 1 << 168;\n    uint256 internal constant _ROLE_169 = 1 << 169;\n    uint256 internal constant _ROLE_170 = 1 << 170;\n    uint256 internal constant _ROLE_171 = 1 << 171;\n    uint256 internal constant _ROLE_172 = 1 << 172;\n    uint256 internal constant _ROLE_173 = 1 << 173;\n    uint256 internal constant _ROLE_174 = 1 << 174;\n    uint256 internal constant _ROLE_175 = 1 << 175;\n    uint256 internal constant _ROLE_176 = 1 << 176;\n    uint256 internal constant _ROLE_177 = 1 << 177;\n    uint256 internal constant _ROLE_178 = 1 << 178;\n    uint256 internal constant _ROLE_179 = 1 << 179;\n    uint256 internal constant _ROLE_180 = 1 << 180;\n    uint256 internal constant _ROLE_181 = 1 << 181;\n    uint256 internal constant _ROLE_182 = 1 << 182;\n    uint256 internal constant _ROLE_183 = 1 << 183;\n    uint256 internal constant _ROLE_184 = 1 << 184;\n    uint256 internal constant _ROLE_185 = 1 << 185;\n    uint256 internal constant _ROLE_186 = 1 << 186;\n    uint256 internal constant _ROLE_187 = 1 << 187;\n    uint256 internal constant _ROLE_188 = 1 << 188;\n    uint256 internal constant _ROLE_189 = 1 << 189;\n    uint256 internal constant _ROLE_190 = 1 << 190;\n    uint256 internal constant _ROLE_191 = 1 << 191;\n    uint256 internal constant _ROLE_192 = 1 << 192;\n    uint256 internal constant _ROLE_193 = 1 << 193;\n    uint256 internal constant _ROLE_194 = 1 << 194;\n    uint256 internal constant _ROLE_195 = 1 << 195;\n    uint256 internal constant _ROLE_196 = 1 << 196;\n    uint256 internal constant _ROLE_197 = 1 << 197;\n    uint256 internal constant _ROLE_198 = 1 << 198;\n    uint256 internal constant _ROLE_199 = 1 << 199;\n    uint256 internal constant _ROLE_200 = 1 << 200;\n    uint256 internal constant _ROLE_201 = 1 << 201;\n    uint256 internal constant _ROLE_202 = 1 << 202;\n    uint256 internal constant _ROLE_203 = 1 << 203;\n    uint256 internal constant _ROLE_204 = 1 << 204;\n    uint256 internal constant _ROLE_205 = 1 << 205;\n    uint256 internal constant _ROLE_206 = 1 << 206;\n    uint256 internal constant _ROLE_207 = 1 << 207;\n    uint256 internal constant _ROLE_208 = 1 << 208;\n    uint256 internal constant _ROLE_209 = 1 << 209;\n    uint256 internal constant _ROLE_210 = 1 << 210;\n    uint256 internal constant _ROLE_211 = 1 << 211;\n    uint256 internal constant _ROLE_212 = 1 << 212;\n    uint256 internal constant _ROLE_213 = 1 << 213;\n    uint256 internal constant _ROLE_214 = 1 << 214;\n    uint256 internal constant _ROLE_215 = 1 << 215;\n    uint256 internal constant _ROLE_216 = 1 << 216;\n    uint256 internal constant _ROLE_217 = 1 << 217;\n    uint256 internal constant _ROLE_218 = 1 << 218;\n    uint256 internal constant _ROLE_219 = 1 << 219;\n    uint256 internal constant _ROLE_220 = 1 << 220;\n    uint256 internal constant _ROLE_221 = 1 << 221;\n    uint256 internal constant _ROLE_222 = 1 << 222;\n    uint256 internal constant _ROLE_223 = 1 << 223;\n    uint256 internal constant _ROLE_224 = 1 << 224;\n    uint256 internal constant _ROLE_225 = 1 << 225;\n    uint256 internal constant _ROLE_226 = 1 << 226;\n    uint256 internal constant _ROLE_227 = 1 << 227;\n    uint256 internal constant _ROLE_228 = 1 << 228;\n    uint256 internal constant _ROLE_229 = 1 << 229;\n    uint256 internal constant _ROLE_230 = 1 << 230;\n    uint256 internal constant _ROLE_231 = 1 << 231;\n    uint256 internal constant _ROLE_232 = 1 << 232;\n    uint256 internal constant _ROLE_233 = 1 << 233;\n    uint256 internal constant _ROLE_234 = 1 << 234;\n    uint256 internal constant _ROLE_235 = 1 << 235;\n    uint256 internal constant _ROLE_236 = 1 << 236;\n    uint256 internal constant _ROLE_237 = 1 << 237;\n    uint256 internal constant _ROLE_238 = 1 << 238;\n    uint256 internal constant _ROLE_239 = 1 << 239;\n    uint256 internal constant _ROLE_240 = 1 << 240;\n    uint256 internal constant _ROLE_241 = 1 << 241;\n    uint256 internal constant _ROLE_242 = 1 << 242;\n    uint256 internal constant _ROLE_243 = 1 << 243;\n    uint256 internal constant _ROLE_244 = 1 << 244;\n    uint256 internal constant _ROLE_245 = 1 << 245;\n    uint256 internal constant _ROLE_246 = 1 << 246;\n    uint256 internal constant _ROLE_247 = 1 << 247;\n    uint256 internal constant _ROLE_248 = 1 << 248;\n    uint256 internal constant _ROLE_249 = 1 << 249;\n    uint256 internal constant _ROLE_250 = 1 << 250;\n    uint256 internal constant _ROLE_251 = 1 << 251;\n    uint256 internal constant _ROLE_252 = 1 << 252;\n    uint256 internal constant _ROLE_253 = 1 << 253;\n    uint256 internal constant _ROLE_254 = 1 << 254;\n    uint256 internal constant _ROLE_255 = 1 << 255;\n}\n"},"lib/solady/src/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Initializable mixin for the upgradeable contracts.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Initializable.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/proxy/utils/Initializable.sol)\nabstract contract Initializable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The contract is already initialized.\n    error InvalidInitialization();\n\n    /// @dev The contract is not initializing.\n    error NotInitializing();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Triggered when the contract has been initialized.\n    event Initialized(uint64 version);\n\n    /// @dev `keccak256(bytes(\"Initialized(uint64)\"))`.\n    bytes32 private constant _INITIALIZED_EVENT_SIGNATURE =\n        0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The default initializable slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_INITIALIZABLE_SLOT\")))))`.\n    ///\n    /// Bits Layout:\n    /// - [0]     `initializing`\n    /// - [1..64] `initializedVersion`\n    bytes32 private constant _INITIALIZABLE_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffbf601132;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                        CONSTRUCTOR                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    constructor() {\n        // Construction time check to ensure that `_initializableSlot()` is not\n        // overridden to zero. Will be optimized away if there is no revert.\n        require(_initializableSlot() != bytes32(0));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         OPERATIONS                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return a non-zero custom storage slot if required.\n    function _initializableSlot() internal pure virtual returns (bytes32) {\n        return _INITIALIZABLE_SLOT;\n    }\n\n    /// @dev Guards an initializer function so that it can be invoked at most once.\n    ///\n    /// You can guard a function with `onlyInitializing` such that it can be called\n    /// through a function guarded with `initializer`.\n    ///\n    /// This is similar to `reinitializer(1)`, except that in the context of a constructor,\n    /// an `initializer` guarded function can be invoked multiple times.\n    /// This can be useful during testing and is not expected to be used in production.\n    ///\n    /// Emits an {Initialized} event.\n    modifier initializer() virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let i := sload(s)\n            // Set `initializing` to 1, `initializedVersion` to 1.\n            sstore(s, 3)\n            // If `!(initializing == 0 && initializedVersion == 0)`.\n            if i {\n                // If `!(address(this).code.length == 0 && initializedVersion == 1)`.\n                if iszero(lt(extcodesize(address()), eq(shr(1, i), 1))) {\n                    mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                    revert(0x1c, 0x04)\n                }\n                s := shl(shl(255, i), s) // Skip initializing if `initializing == 1`.\n            }\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            if s {\n                // Set `initializing` to 0, `initializedVersion` to 1.\n                sstore(s, 2)\n                // Emit the {Initialized} event.\n                mstore(0x20, 1)\n                log1(0x20, 0x20, _INITIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Guards a reinitializer function so that it can be invoked at most once.\n    ///\n    /// You can guard a function with `onlyInitializing` such that it can be called\n    /// through a function guarded with `reinitializer`.\n    ///\n    /// Emits an {Initialized} event.\n    modifier reinitializer(uint64 version) virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Clean upper bits, and shift left by 1 to make space for the initializing bit.\n            version := shl(1, and(version, 0xffffffffffffffff))\n            let i := sload(s)\n            // If `initializing == 1 || initializedVersion >= version`.\n            if iszero(lt(and(i, 1), lt(i, version))) {\n                mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                revert(0x1c, 0x04)\n            }\n            // Set `initializing` to 1, `initializedVersion` to `version`.\n            sstore(s, or(1, version))\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Set `initializing` to 0, `initializedVersion` to `version`.\n            sstore(s, version)\n            // Emit the {Initialized} event.\n            mstore(0x20, shr(1, version))\n            log1(0x20, 0x20, _INITIALIZED_EVENT_SIGNATURE)\n        }\n    }\n\n    /// @dev Guards a function such that it can only be called in the scope\n    /// of a function guarded with `initializer` or `reinitializer`.\n    modifier onlyInitializing() virtual {\n        _checkInitializing();\n        _;\n    }\n\n    /// @dev Reverts if the contract is not initializing.\n    function _checkInitializing() internal view virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(and(1, sload(s))) {\n                mstore(0x00, 0xd7e6bcf8) // `NotInitializing()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Locks any future initializations by setting the initialized version to `2**64 - 1`.\n    ///\n    /// Calling this in the constructor will prevent the contract from being initialized\n    /// or reinitialized. It is recommended to use this to lock implementation contracts\n    /// that are designed to be called through proxies.\n    ///\n    /// Emits an {Initialized} event the first time it is successfully called.\n    function _disableInitializers() internal virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let i := sload(s)\n            if and(i, 1) {\n                mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                revert(0x1c, 0x04)\n            }\n            let uint64max := 0xffffffffffffffff\n            if iszero(eq(shr(1, i), uint64max)) {\n                // Set `initializing` to 0, `initializedVersion` to `2**64 - 1`.\n                sstore(s, shl(1, uint64max))\n                // Emit the {Initialized} event.\n                mstore(0x20, uint64max)\n                log1(0x20, 0x20, _INITIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Returns the highest version that has been initialized.\n    function _getInitializedVersion() internal view virtual returns (uint64 version) {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            version := shr(1, sload(s))\n        }\n    }\n\n    /// @dev Returns whether the contract is currently initializing.\n    function _isInitializing() internal view virtual returns (bool result) {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := and(1, sload(s))\n        }\n    }\n}\n"},"lib/solady/src/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {CallContextChecker} from \"./CallContextChecker.sol\";\n\n/// @notice UUPS proxy mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/UUPSUpgradeable.sol)\n/// @author Modified from OpenZeppelin\n/// (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/utils/UUPSUpgradeable.sol)\n///\n/// @dev Note:\n/// - This implementation is intended to be used with ERC1967 proxies.\n/// See: `LibClone.deployERC1967` and related functions.\n/// - This implementation is NOT compatible with legacy OpenZeppelin proxies\n/// which do not store the implementation at `_ERC1967_IMPLEMENTATION_SLOT`.\nabstract contract UUPSUpgradeable is CallContextChecker {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The upgrade failed.\n    error UpgradeFailed();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Emitted when the proxy's implementation is upgraded.\n    event Upgraded(address indexed implementation);\n\n    /// @dev `keccak256(bytes(\"Upgraded(address)\"))`.\n    uint256 private constant _UPGRADED_EVENT_SIGNATURE =\n        0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ERC-1967 storage slot for the implementation in the proxy.\n    /// `uint256(keccak256(\"eip1967.proxy.implementation\")) - 1`.\n    bytes32 internal constant _ERC1967_IMPLEMENTATION_SLOT =\n        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      UUPS OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Please override this function to check if `msg.sender` is authorized\n    /// to upgrade the proxy to `newImplementation`, reverting if not.\n    /// ```\n    ///     function _authorizeUpgrade(address) internal override onlyOwner {}\n    /// ```\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /// @dev Returns the storage slot used by the implementation,\n    /// as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822).\n    ///\n    /// Note: The `notDelegated` modifier prevents accidental upgrades to\n    /// an implementation that is a proxy contract.\n    function proxiableUUID() public view virtual notDelegated returns (bytes32) {\n        // This function must always return `_ERC1967_IMPLEMENTATION_SLOT` to comply with ERC1967.\n        return _ERC1967_IMPLEMENTATION_SLOT;\n    }\n\n    /// @dev Upgrades the proxy's implementation to `newImplementation`.\n    /// Emits a {Upgraded} event.\n    ///\n    /// Note: Passing in empty `data` skips the delegatecall to `newImplementation`.\n    function upgradeToAndCall(address newImplementation, bytes calldata data)\n        public\n        payable\n        virtual\n        onlyProxy\n    {\n        _authorizeUpgrade(newImplementation);\n        /// @solidity memory-safe-assembly\n        assembly {\n            newImplementation := shr(96, shl(96, newImplementation)) // Clears upper 96 bits.\n            mstore(0x00, returndatasize())\n            mstore(0x01, 0x52d1902d) // `proxiableUUID()`.\n            let s := _ERC1967_IMPLEMENTATION_SLOT\n            // Check if `newImplementation` implements `proxiableUUID` correctly.\n            if iszero(eq(mload(staticcall(gas(), newImplementation, 0x1d, 0x04, 0x01, 0x20)), s)) {\n                mstore(0x01, 0x55299b49) // `UpgradeFailed()`.\n                revert(0x1d, 0x04)\n            }\n            // Emit the {Upgraded} event.\n            log2(codesize(), 0x00, _UPGRADED_EVENT_SIGNATURE, newImplementation)\n            sstore(s, newImplementation) // Updates the implementation.\n\n            // Perform a delegatecall to `newImplementation` if `data` is non-empty.\n            if data.length {\n                // Forwards the `data` to `newImplementation` via delegatecall.\n                let m := mload(0x40)\n                calldatacopy(m, data.offset, data.length)\n                if iszero(delegatecall(gas(), newImplementation, m, data.length, codesize(), 0x00))\n                {\n                    // Bubble up the revert if the call reverts.\n                    returndatacopy(m, 0x00, returndatasize())\n                    revert(m, returndatasize())\n                }\n            }\n        }\n    }\n}\n"},"lib/solady/src/utils/CallContextChecker.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Call context checker mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/CallContextChecker.sol)\ncontract CallContextChecker {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The call is from an unauthorized call context.\n    error UnauthorizedCallContext();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         IMMUTABLES                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For checking if the context is a delegate call.\n    ///\n    /// Note: To enable use cases with an immutable default implementation in the bytecode,\n    /// (see: ERC6551Proxy), we don't require that the proxy address must match the\n    /// value stored in the implementation slot, which may not be initialized.\n    uint256 private immutable __self = uint256(uint160(address(this)));\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                    CALL CONTEXT CHECKS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // A proxy call can be either via a `delegatecall` to an implementation,\n    // or a 7702 call on an authority that points to a delegation.\n\n    /// @dev Returns whether the current call context is on a EIP7702 authority\n    /// (i.e. externally owned account).\n    function _onEIP7702Authority() internal view virtual returns (bool result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            extcodecopy(address(), 0x00, 0x00, 0x20)\n            // Note: Checking that it starts with hex\"ef01\" is the most general and futureproof.\n            // 7702 bytecode is `abi.encodePacked(hex\"ef01\", uint8(version), address(delegation))`.\n            result := eq(0xef01, shr(240, mload(0x00)))\n        }\n    }\n\n    /// @dev Returns the implementation of this contract.\n    function _selfImplementation() internal view virtual returns (address) {\n        return address(uint160(__self));\n    }\n\n    /// @dev Returns whether the current call context is on the implementation itself.\n    function _onImplementation() internal view virtual returns (bool) {\n        return __self == uint160(address(this));\n    }\n\n    /// @dev Requires that the current call context is performed via a EIP7702 authority.\n    function _checkOnlyEIP7702Authority() internal view virtual {\n        if (!_onEIP7702Authority()) _revertUnauthorizedCallContext();\n    }\n\n    /// @dev Requires that the current call context is performed via a proxy.\n    function _checkOnlyProxy() internal view virtual {\n        if (_onImplementation()) _revertUnauthorizedCallContext();\n    }\n\n    /// @dev Requires that the current call context is NOT performed via a proxy.\n    /// This is the opposite of `checkOnlyProxy`.\n    function _checkNotDelegated() internal view virtual {\n        if (!_onImplementation()) _revertUnauthorizedCallContext();\n    }\n\n    /// @dev Requires that the current call context is performed via a EIP7702 authority.\n    modifier onlyEIP7702Authority() virtual {\n        _checkOnlyEIP7702Authority();\n        _;\n    }\n\n    /// @dev Requires that the current call context is performed via a proxy.\n    modifier onlyProxy() virtual {\n        _checkOnlyProxy();\n        _;\n    }\n\n    /// @dev Requires that the current call context is NOT performed via a proxy.\n    /// This is the opposite of `onlyProxy`.\n    modifier notDelegated() virtual {\n        _checkNotDelegated();\n        _;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    function _revertUnauthorizedCallContext() private pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x9f03a026) // `UnauthorizedCallContext()`.\n            revert(0x1c, 0x04)\n        }\n    }\n}\n"}},"language":"Solidity","settings":{"viaIR":false,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"osaka","remappings":["@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@solady/=lib/solady/","@forge-std/=lib/forge-std/","@deposit-wallet/src/=src/"]}},"stdJsonOutput":{"sources":{"src/Errors.sol":{"id":7},"src/libraries/WalletLib.sol":{"id":9},"src/DepositWalletFactory.sol":{"id":6},"lib/solady/src/auth/Ownable.sol":{"id":0},"lib/solady/src/utils/LibClone.sol":{"id":4},"src/interfaces/IDepositWallet.sol":{"id":8},"lib/solady/src/auth/OwnableRoles.sol":{"id":1},"lib/solady/src/utils/Initializable.sol":{"id":3},"lib/solady/src/utils/UUPSUpgradeable.sol":{"id":5},"lib/solady/src/utils/CallContextChecker.sol":{"id":2}},"contracts":{"src/DepositWalletFactory.sol":{"DepositWalletFactory":{"abi":[{"type":"constructor","inputs":[{"name":"_beacon","type":"address","internalType":"address"},{"name":"_legacyImpl","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"ArrayLengthMismatch","type":"error","inputs":[]},{"name":"ImplementationNotAuthorized","type":"error","inputs":[]},{"name":"ImplementationNotDeployed","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"InvalidTimelockDelay","type":"error","inputs":[]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"OnlyAdmin","type":"error","inputs":[]},{"name":"OnlyLegacyDeployer","type":"error","inputs":[]},{"name":"OnlyOperator","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"UnauthorizedCallContext","type":"error","inputs":[]},{"name":"UpgradeFailed","type":"error","inputs":[]},{"name":"ZeroAddress","type":"error","inputs":[]},{"name":"ImplementationAuthorized","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ImplementationSet","type":"event","inputs":[{"name":"Implementation","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"ImplementationUnauthorized","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"OwnershipHandoverCanceled","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipHandoverRequested","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"oldOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RolesUpdated","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"roles","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"TimelockDelaySet","type":"event","inputs":[{"name":"timelockDelay","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"WalletDeployed","type":"event","inputs":[{"name":"wallet","type":"address","indexed":true,"internalType":"address"},{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"id","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"implementation","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"BEACON","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"LEGACY_IMPL","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"MAX_TIMELOCK_DELAY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"addAdmin","type":"function","inputs":[{"name":"_admin","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"addLegacyDeployer","type":"function","inputs":[{"name":"_legacyDeployer","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"addOperator","type":"function","inputs":[{"name":"_operator","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"authorizeImplementation","type":"function","inputs":[{"name":"_implementation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"authorizedImplementation","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"deploy","type":"function","inputs":[{"name":"_owners","type":"address[]","internalType":"address[]"},{"name":"_ids","type":"bytes32[]","internalType":"bytes32[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"deployLegacy","type":"function","inputs":[{"name":"_owners","type":"address[]","internalType":"address[]"},{"name":"_ids","type":"bytes32[]","internalType":"bytes32[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"grantRoles","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"hasAllRoles","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"hasAnyRole","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"implementation","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"_owner","type":"address","internalType":"address"},{"name":"_admin","type":"address","internalType":"address"},{"name":"_timelockDelay","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isAdmin","type":"function","inputs":[{"name":"_admin","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isLegacyDeployer","type":"function","inputs":[{"name":"_legacyDeployer","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isOperator","type":"function","inputs":[{"name":"_operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownershipHandoverExpiresAt","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"predictLegacyWalletAddress","type":"function","inputs":[{"name":"_id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"predictWalletAddress","type":"function","inputs":[{"name":"_id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"predictWalletAddress","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"_id","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"proxy","type":"function","inputs":[{"name":"_batches","type":"tuple[]","components":[{"name":"wallet","type":"address","internalType":"address"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"calls","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"internalType":"struct Call[]"}],"internalType":"struct Batch[]"},{"name":"_signatures","type":"bytes[]","internalType":"bytes[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeAdmin","type":"function","inputs":[{"name":"_admin","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeLegacyDeployer","type":"function","inputs":[{"name":"_legacyDeployer","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeOperator","type":"function","inputs":[{"name":"_operator","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"renounceRoles","type":"function","inputs":[{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"revokeRoles","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"roles","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"rolesOf","type":"function","inputs":[{"name":"user","type":"address","internalType":"address"}],"outputs":[{"name":"roles","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"setImplementation","type":"function","inputs":[{"name":"_implementation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setTimelockDelay","type":"function","inputs":[{"name":"_timelockDelay","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"timelockDelay","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"unauthorizeImplementation","type":"function","inputs":[{"name":"_implementation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.34+commit.80d5c536\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_beacon\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_legacyImpl\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ImplementationNotAuthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ImplementationNotDeployed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInitialization\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTimelockDelay\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewOwnerIsZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoHandoverRequest\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotInitializing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyLegacyDeployer\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyOperator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnauthorizedCallContext\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UpgradeFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"ImplementationAuthorized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"Implementation\",\"type\":\"address\"}],\"name\":\"ImplementationSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"ImplementationUnauthorized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"version\",\"type\":\"uint64\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"OwnershipHandoverCanceled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"OwnershipHandoverRequested\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"roles\",\"type\":\"uint256\"}],\"name\":\"RolesUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timelockDelay\",\"type\":\"uint256\"}],\"name\":\"TimelockDelaySet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"WalletDeployed\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BEACON\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"LEGACY_IMPL\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MAX_TIMELOCK_DELAY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_admin\",\"type\":\"address\"}],\"name\":\"addAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_legacyDeployer\",\"type\":\"address\"}],\"name\":\"addLegacyDeployer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"}],\"name\":\"addOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_implementation\",\"type\":\"address\"}],\"name\":\"authorizeImplementation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"authorizedImplementation\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"cancelOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"completeOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_owners\",\"type\":\"address[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"_ids\",\"type\":\"bytes32[]\"}],\"name\":\"deploy\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_owners\",\"type\":\"address[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"_ids\",\"type\":\"bytes32[]\"}],\"name\":\"deployLegacy\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"roles\",\"type\":\"uint256\"}],\"name\":\"grantRoles\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"roles\",\"type\":\"uint256\"}],\"name\":\"hasAllRoles\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"roles\",\"type\":\"uint256\"}],\"name\":\"hasAnyRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_admin\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_timelockDelay\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_admin\",\"type\":\"address\"}],\"name\":\"isAdmin\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_legacyDeployer\",\"type\":\"address\"}],\"name\":\"isLegacyDeployer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"result\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"ownershipHandoverExpiresAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_id\",\"type\":\"bytes32\"}],\"name\":\"predictLegacyWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_id\",\"type\":\"bytes32\"}],\"name\":\"predictWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"_id\",\"type\":\"bytes32\"}],\"name\":\"predictWalletAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"struct Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"internalType\":\"struct Batch[]\",\"name\":\"_batches\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes[]\",\"name\":\"_signatures\",\"type\":\"bytes[]\"}],\"name\":\"proxy\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_admin\",\"type\":\"address\"}],\"name\":\"removeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_legacyDeployer\",\"type\":\"address\"}],\"name\":\"removeLegacyDeployer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"}],\"name\":\"removeOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"roles\",\"type\":\"uint256\"}],\"name\":\"renounceRoles\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"requestOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"roles\",\"type\":\"uint256\"}],\"name\":\"revokeRoles\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"}],\"name\":\"rolesOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"roles\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_implementation\",\"type\":\"address\"}],\"name\":\"setImplementation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_timelockDelay\",\"type\":\"uint256\"}],\"name\":\"setTimelockDelay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"timelockDelay\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_implementation\",\"type\":\"address\"}],\"name\":\"unauthorizeImplementation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Polymarket\",\"details\":\"Uses a four-tier role model:      - **Owner**: can add/remove admins, manage implementations, and authorize UUPS upgrades                   of the factory itself.      - **Admin** (ROLE_0): can add/remove operators and legacy deployers, and configure the                   timelock delay.      - **Operator** (ROLE_1): can deploy beacon-shape wallets and proxy batch executions.      - **Legacy deployer** (ROLE_2): can deploy legacy-shape wallets via {deployLegacy}.      Two deploy paths, fed identical `args`/`salt`:      - {deploy} produces an ERC-1967 beacon proxy bound to {BEACON}.      - {deployLegacy} produces a plain ERC-1967 proxy embedding {LEGACY_IMPL}. This reproduces        the exact addresses the pre-beacon factory derived, because the address depends only on        (this factory's address, the embedded implementation, the Solady proxy template, the        id) — never on this factory's own bytecode. It exists for ids whose legacy address has        already been handed out, and for cross-chain recovery: deployed at the canonical        factory address on another chain, it mints a wallet at the identical address a user's        Polygon deposit wallet occupies.      Both paths fail closed: they revert unless the embedded implementation/beacon already      holds code, so a misordered rollout cannot mint ownerless, seizable wallets.      Storage slots 0/1/2 (`implementation`, `timelockDelay`, `authorizedImplementation`) are      preserved from prior versions so this contract can be installed as a UUPS upgrade on the      live factory proxy without corrupting state.\",\"errors\":{\"AlreadyInitialized()\":[{\"details\":\"Cannot double-initialize.\"}],\"ImplementationNotAuthorized()\":[{\"details\":\"Deprecated post-migration; only thrown by the legacy {setImplementation} surface.\"}],\"ImplementationNotDeployed()\":[{\"details\":\"Fail-closed guard: deploying a proxy whose implementation/beacon is code-less would      let `initialize` silently succeed as a delegatecall to an empty account, minting an      ownerless wallet that anyone could later seize.\"}],\"InvalidInitialization()\":[{\"details\":\"The contract is already initialized.\"}],\"NewOwnerIsZeroAddress()\":[{\"details\":\"The `newOwner` cannot be the zero address.\"}],\"NoHandoverRequest()\":[{\"details\":\"The `pendingOwner` does not have a valid handover request.\"}],\"NotInitializing()\":[{\"details\":\"The contract is not initializing.\"}],\"Unauthorized()\":[{\"details\":\"The caller is not authorized to call the function.\"}],\"UnauthorizedCallContext()\":[{\"details\":\"The call is from an unauthorized call context.\"}],\"UpgradeFailed()\":[{\"details\":\"The upgrade failed.\"}]},\"events\":{\"ImplementationAuthorized(address)\":{\"details\":\"Deprecated post-migration; only emitted while the legacy upgrade surface is in use      (e.g., authorizing {BeaconForwarder}).\",\"params\":{\"implementation\":\"The address of the authorized implementation.\"}},\"ImplementationSet(address)\":{\"details\":\"Deprecated; the legacy slot-0 `implementation` pointer is no longer consulted by      {DepositWalletFactory.deploy}.\",\"params\":{\"Implementation\":\"The address of the new default implementation.\"}},\"ImplementationUnauthorized(address)\":{\"details\":\"Deprecated post-migration; only emitted while the legacy upgrade surface is in use.\",\"params\":{\"implementation\":\"The address of the unauthorized implementation.\"}},\"Initialized(uint64)\":{\"details\":\"Triggered when the contract has been initialized.\"},\"OwnershipHandoverCanceled(address)\":{\"details\":\"The ownership handover to `pendingOwner` has been canceled.\"},\"OwnershipHandoverRequested(address)\":{\"details\":\"An ownership handover to `pendingOwner` has been requested.\"},\"OwnershipTransferred(address,address)\":{\"details\":\"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event.\"},\"RolesUpdated(address,uint256)\":{\"details\":\"The `user`'s roles is updated to `roles`. Each bit of `roles` represents whether the role is set.\"},\"TimelockDelaySet(uint256)\":{\"params\":{\"timelockDelay\":\"The new timelock delay in seconds.\"}},\"Upgraded(address)\":{\"details\":\"Emitted when the proxy's implementation is upgraded.\"},\"WalletDeployed(address,address,bytes32,address)\":{\"params\":{\"id\":\"The unique identifier assigned to the wallet.\",\"implementation\":\"The address embedded in the proxy: the beacon for beacon-shape                       wallets, or the legacy implementation for legacy-shape wallets.\",\"owner\":\"The initial owner of the wallet.\",\"wallet\":\"The address of the newly deployed wallet proxy.\"}}},\"kind\":\"dev\",\"methods\":{\"addAdmin(address)\":{\"params\":{\"_admin\":\"The address to grant the admin role.\"}},\"addLegacyDeployer(address)\":{\"params\":{\"_legacyDeployer\":\"The address to grant the legacy-deployer role.\"}},\"addOperator(address)\":{\"params\":{\"_operator\":\"The address to grant the operator role.\"}},\"authorizeImplementation(address)\":{\"details\":\"Used during the migration window to authorize {BeaconForwarder}; will be deprecated      after the migration window closes.\",\"params\":{\"_implementation\":\"The implementation address to authorize.\"}},\"cancelOwnershipHandover()\":{\"details\":\"Cancels the two-step ownership handover to the caller, if any.\"},\"completeOwnershipHandover(address)\":{\"details\":\"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`.\"},\"constructor\":{\"details\":\"Sets the beacon and legacy implementation, then disables initializers on the      implementation contract.\",\"params\":{\"_beacon\":\"The beacon contract address for beacon-shape wallets.\",\"_legacyImpl\":\"The legacy implementation address embedded in legacy-shape wallets.\"}},\"deploy(address[],bytes32[])\":{\"details\":\"It is the operator's responsibility to ensure that each `_id` is unique.      Duplicate IDs will cause the deployment to revert because the deterministic      address is already occupied. Note: beacon-shape and legacy-shape wallets for the      same `_id` live at DIFFERENT addresses (different proxy template), so they never      collide; the operator must dedupe IDs across both shapes off-chain.\",\"params\":{\"_ids\":\"The unique identifiers for each wallet.\",\"_owners\":\"The initial owner addresses for each wallet.\"}},\"deployLegacy(address[],bytes32[])\":{\"details\":\"Restricted to the legacy-deployer role (ROLE_2), granted independently of the      operator role. Used for ids whose legacy address has already been handed out, and for      cross-chain recovery: a wallet deployed here lands at the same address the user's      Polygon deposit wallet occupies. The resulting wallet runs {LEGACY_IMPL} (the V1      implementation). See {deploy} for the ID-uniqueness and cross-shape notes.\",\"params\":{\"_ids\":\"The unique identifiers for each wallet.\",\"_owners\":\"The initial owner addresses for each wallet.\"}},\"grantRoles(address,uint256)\":{\"details\":\"Allows the owner to grant `user` `roles`. If the `user` already has a role, then it will be an no-op for the role.\"},\"hasAllRoles(address,uint256)\":{\"details\":\"Returns whether `user` has all of `roles`.\"},\"hasAnyRole(address,uint256)\":{\"details\":\"Returns whether `user` has any of `roles`.\"},\"initialize(address,address,uint256)\":{\"params\":{\"_admin\":\"The address to grant the initial admin role.\",\"_owner\":\"The address to set as the factory owner.\",\"_timelockDelay\":\"The initial timelock delay in seconds.\"}},\"isAdmin(address)\":{\"params\":{\"_admin\":\"The address to check.\"},\"returns\":{\"_0\":\"True if the address is an admin.\"}},\"isLegacyDeployer(address)\":{\"params\":{\"_legacyDeployer\":\"The address to check.\"},\"returns\":{\"_0\":\"True if the address is a legacy deployer.\"}},\"isOperator(address)\":{\"params\":{\"_operator\":\"The address to check.\"},\"returns\":{\"_0\":\"True if the address is an operator.\"}},\"owner()\":{\"details\":\"Returns the owner of the contract.\"},\"ownershipHandoverExpiresAt(address)\":{\"details\":\"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\"},\"predictLegacyWalletAddress(bytes32)\":{\"details\":\"This matches the address the pre-beacon factory assigned to a wallet with the same      `_id` — including, on other chains, the address of the user's Polygon wallet —      enabling cross-chain recovery at the identical address.\",\"params\":{\"_id\":\"The unique identifier for the wallet.\"},\"returns\":{\"_0\":\"The predicted legacy wallet address.\"}},\"predictWalletAddress(address,bytes32)\":{\"details\":\"Deprecated; retained for ABI compatibility. The first argument is ignored — wallets      are now beacon proxies bound to {BEACON}. Prefer {predictWalletAddress(bytes32)}.\",\"params\":{\"_id\":\"The unique identifier for the wallet.\"},\"returns\":{\"_0\":\"The predicted wallet proxy address.\"}},\"predictWalletAddress(bytes32)\":{\"details\":\"This returns the address derived from the beacon-proxy template. For the address of a      legacy-shape (ERC-1967, UUPS) wallet, use {predictLegacyWalletAddress} — the two      shapes live at different deterministic addresses because the proxy bytecode (and      therefore the CREATE2 derivation) differs.\",\"params\":{\"_id\":\"The unique identifier for the wallet.\"},\"returns\":{\"_0\":\"The predicted beacon-proxy wallet address.\"}},\"proxiableUUID()\":{\"details\":\"Returns the storage slot used by the implementation, as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822). Note: The `notDelegated` modifier prevents accidental upgrades to an implementation that is a proxy contract.\"},\"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])\":{\"details\":\"Each batch is forwarded to its target wallet's `execute` function. Works for both      wallet shapes (the `Batch` layout is identical across the legacy and current      implementations).\",\"params\":{\"_batches\":\"The batches to execute.\",\"_signatures\":\"The corresponding signatures for each batch.\"}},\"removeAdmin(address)\":{\"params\":{\"_admin\":\"The address to remove the admin role from.\"}},\"removeLegacyDeployer(address)\":{\"params\":{\"_legacyDeployer\":\"The address to remove the legacy-deployer role from.\"}},\"removeOperator(address)\":{\"params\":{\"_operator\":\"The address to remove the operator role from.\"}},\"renounceOwnership()\":{\"details\":\"Allows the owner to renounce their ownership.\"},\"renounceRoles(uint256)\":{\"details\":\"Allow the caller to remove their own roles. If the caller does not have a role, then it will be an no-op for the role.\"},\"requestOwnershipHandover()\":{\"details\":\"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default.\"},\"revokeRoles(address,uint256)\":{\"details\":\"Allows the owner to remove `user` `roles`. If the `user` does not have a role, then it will be an no-op for the role.\"},\"rolesOf(address)\":{\"details\":\"Returns the roles of `user`.\"},\"setImplementation(address)\":{\"details\":\"Deprecated; retained for ABI compatibility. Has no effect on {deploy} (which uses      {BEACON}) or {deployLegacy} (which uses {LEGACY_IMPL}).\",\"params\":{\"_implementation\":\"The new default implementation address.\"}},\"setTimelockDelay(uint256)\":{\"params\":{\"_timelockDelay\":\"The new timelock delay in seconds.\"}},\"transferOwnership(address)\":{\"details\":\"Allows the owner to transfer the ownership to `newOwner`.\"},\"unauthorizeImplementation(address)\":{\"details\":\"Used during the migration window; will be deprecated after the window closes.\",\"params\":{\"_implementation\":\"The implementation address to unauthorize.\"}},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrades the proxy's implementation to `newImplementation`. Emits a {Upgraded} event. Note: Passing in empty `data` skips the delegatecall to `newImplementation`.\"}},\"stateVariables\":{\"LEGACY_IMPL\":{\"details\":\"Set to the live legacy DepositWallet implementation so {deployLegacy} reproduces the      exact wallet addresses the pre-beacon factory deployed.\"},\"authorizedImplementation\":{\"details\":\"Legacy-shape wallets gate their `upgrade` self-call on this mapping. Used during the      migration window to authorize {BeaconForwarder} so existing UUPS wallets can opt into      the beacon. Will be deprecated after the migration window closes.\"},\"implementation\":{\"details\":\"Deprecated; not consulted by {deploy} or {deployLegacy}. Retained only to preserve      slot 0 of the live factory proxy so this contract can be installed via UUPS upgrade      in place.\"}},\"title\":\"DepositWalletFactory\",\"version\":1},\"userdoc\":{\"errors\":{\"ArrayLengthMismatch()\":[{\"notice\":\"Thrown when paired input arrays have mismatched lengths.\"}],\"ImplementationNotAuthorized()\":[{\"notice\":\"Thrown when an implementation has not been authorized.\"}],\"ImplementationNotDeployed()\":[{\"notice\":\"Thrown when a deploy target (the beacon, its resolved implementation, or the         legacy implementation) has no code.\"}],\"InvalidTimelockDelay()\":[{\"notice\":\"Thrown when the provided timelock delay is zero or exceeds the maximum.\"}],\"OnlyAdmin()\":[{\"notice\":\"Thrown when the caller does not have the admin role.\"}],\"OnlyLegacyDeployer()\":[{\"notice\":\"Thrown when the caller does not have the legacy-deployer role.\"}],\"OnlyOperator()\":[{\"notice\":\"Thrown when the caller does not have the operator role.\"}],\"ZeroAddress()\":[{\"notice\":\"Thrown when the zero address is provided where a non-zero address is required.\"}]},\"events\":{\"ImplementationAuthorized(address)\":{\"notice\":\"Emitted when a wallet implementation is added to the authorized set.\"},\"ImplementationSet(address)\":{\"notice\":\"Emitted when the default wallet implementation is updated.\"},\"ImplementationUnauthorized(address)\":{\"notice\":\"Emitted when a wallet implementation is removed from the authorized set.\"},\"TimelockDelaySet(uint256)\":{\"notice\":\"Emitted when the timelock delay is updated.\"},\"WalletDeployed(address,address,bytes32,address)\":{\"notice\":\"Emitted when a new deposit wallet is deployed.\"}},\"kind\":\"user\",\"methods\":{\"BEACON()\":{\"notice\":\"The beacon that resolves the implementation for beacon-shape wallets.\"},\"LEGACY_IMPL()\":{\"notice\":\"The implementation embedded in legacy-shape (ERC-1967, UUPS) wallets.\"},\"MAX_TIMELOCK_DELAY()\":{\"notice\":\"The maximum allowed timelock delay (7 days).\"},\"addAdmin(address)\":{\"notice\":\"Grants the admin role to an address.\"},\"addLegacyDeployer(address)\":{\"notice\":\"Grants the legacy-deployer role to an address.\"},\"addOperator(address)\":{\"notice\":\"Grants the operator role to an address.\"},\"authorizeImplementation(address)\":{\"notice\":\"Authorizes an implementation address for legacy UUPS upgrades.\"},\"authorizedImplementation(address)\":{\"notice\":\"Tracks which implementation addresses are authorized for legacy UUPS upgrades.\"},\"deploy(address[],bytes32[])\":{\"notice\":\"Deploys one or more beacon-shape deposit wallets with deterministic addresses.\"},\"deployLegacy(address[],bytes32[])\":{\"notice\":\"Deploys one or more legacy-shape (ERC-1967, UUPS) deposit wallets with         deterministic addresses that match the pre-beacon factory's derivation.\"},\"implementation()\":{\"notice\":\"Legacy default wallet implementation pointer.\"},\"initialize(address,address,uint256)\":{\"notice\":\"Initializes the factory with an owner, admin, and timelock delay.\"},\"isAdmin(address)\":{\"notice\":\"Returns whether the given address has the admin role.\"},\"isLegacyDeployer(address)\":{\"notice\":\"Returns whether the given address has the legacy-deployer role.\"},\"isOperator(address)\":{\"notice\":\"Returns whether the given address has the operator role.\"},\"predictLegacyWalletAddress(bytes32)\":{\"notice\":\"Predicts the deterministic address of a legacy-shape (ERC-1967) wallet before         deployment.\"},\"predictWalletAddress(address,bytes32)\":{\"notice\":\"Predicts the deterministic address of a wallet before deployment.\"},\"predictWalletAddress(bytes32)\":{\"notice\":\"Predicts the deterministic address of a beacon-proxy wallet before deployment.\"},\"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])\":{\"notice\":\"Proxies batch execution to one or more wallets.\"},\"removeAdmin(address)\":{\"notice\":\"Removes the admin role from an address.\"},\"removeLegacyDeployer(address)\":{\"notice\":\"Removes the legacy-deployer role from an address.\"},\"removeOperator(address)\":{\"notice\":\"Removes the operator role from an address.\"},\"setImplementation(address)\":{\"notice\":\"Sets the legacy slot-0 implementation pointer.\"},\"setTimelockDelay(uint256)\":{\"notice\":\"Sets the timelock delay for paused wallet operations.\"},\"timelockDelay()\":{\"notice\":\"The delay in seconds that must elapse after pausing before the owner can         execute paused-only operations on a wallet.\"},\"unauthorizeImplementation(address)\":{\"notice\":\"Removes an implementation address from the authorized set.\"}},\"notice\":\"Factory contract for deploying and managing DepositWallets. Deploys ERC-1967         beacon proxies going forward, and can also deploy legacy ERC-1967 (UUPS-shaped)         wallets at the exact deterministic addresses the pre-beacon factory used.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/DepositWalletFactory.sol\":\"DepositWalletFactory\"},\"evmVersion\":\"osaka\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[\":@deposit-wallet/src/=src/\",\":@forge-std/=lib/forge-std/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@solady/=lib/solady/\"]},\"sources\":{\"lib/solady/src/auth/Ownable.sol\":{\"keccak256\":\"0xc208cdd9de02bbf4b5edad18b88e23a2be7ff56d2287d5649329dc7cda64b9a3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e8fba079cc7230c617f7493a2e97873f88e59a53a5018fcb2e2b6ac42d8aa5a3\",\"dweb:/ipfs/QmTXg8GSt8hsK2cZhbPFrund1mrwVdkLQmEPoQaFy4fhjs\"]},\"lib/solady/src/auth/OwnableRoles.sol\":{\"keccak256\":\"0x34fc1e43ab0c413faea47d5198d49879ccafd3a46c1657083ec79e3f4ca4359d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://539e93fa51da529c6fdf122a68239652e98a4e31eaf5a08868339404878a095d\",\"dweb:/ipfs/Qmf4SGkn3LDLGAeFmuSnETrQUCa8g8h2dSoukCwyj36yy6\"]},\"lib/solady/src/utils/CallContextChecker.sol\":{\"keccak256\":\"0xc54c743a03f4909826712e9c6b683ca95e8b0c120c55284a9e3572621ebd734b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3d3138009aba3d2fd310636f3cc1d6029e970c57ddb74693bebf2a02d3e6f12d\",\"dweb:/ipfs/QmauMpcVDyQqVnAUF75DXy831LvtxyFS7GND7kge1Zgw55\"]},\"lib/solady/src/utils/Initializable.sol\":{\"keccak256\":\"0x58ee7b2e966232ca1ca9e9e705d8afcefa83fe29d37d6f8361d73015a9db1fe4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://59f134cb038e0a547f0a3dbfe9c9b6939f7b39dff64646a79e8cf2dd6ba14f80\",\"dweb:/ipfs/QmfXt149JQEWsYbLUkS9iLP6kGZqzHYyMg7SsLUUPgafEb\"]},\"lib/solady/src/utils/LibClone.sol\":{\"keccak256\":\"0x1b96fd03a3948155bd2fe95dc4980930c759b174026e18f11bc8e88d55ae030e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://64998d16472a127031ee6a796ed9afcf13dd662afd30eb4d3e2a42c2bc9fd204\",\"dweb:/ipfs/QmTXHGy9t8YTW96tjiZ8RBqmijXUTqc1JznEBqHv8Duc4A\"]},\"lib/solady/src/utils/UUPSUpgradeable.sol\":{\"keccak256\":\"0x63899eaf1a24713464b8084ada33a83c4b7db789fe83ae22f016e39646bee361\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://617fa735ffa8ba31051745614a508abd69d2cfc1b1bc1eb3c772865db5f7ce65\",\"dweb:/ipfs/QmR1pQbHPyXcLbFm2vHrXBs1qRFrGC22gF7wWYamYy8aaE\"]},\"src/DepositWalletFactory.sol\":{\"keccak256\":\"0x99c4cc0d174b518a9066fd3f174bff453e06103b9a8047b4e2fb9bfafe2d832e\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://6755650fde18027cccdac1fd5d0615cf5eac55cd4f0a94c4d944d267aeef326e\",\"dweb:/ipfs/QmYBXh8h13nTP7Khsdy54ycvVGw3mjnbgUE1LX8EEVmERe\"]},\"src/Errors.sol\":{\"keccak256\":\"0x641a144833da4937522a190855503388ac8f43ca1de0db64fc646798f4fa46c8\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://4b40f47875b47995bd7f9e1aba2e724a69c0363d3c801403899630d9f5488365\",\"dweb:/ipfs/Qmf82WsA6eQRRUj6ScpmuBVKavimg3UL85yXYfL6QjdEPu\"]},\"src/interfaces/IDepositWallet.sol\":{\"keccak256\":\"0x4174ab48008387f1ce4c1a5c6052a98968488885b592a9a850dcb6a3a5552f6a\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://ce3320db306c334438f015d12dc94ab7f5f18faf17964cd4d68fa863380ea246\",\"dweb:/ipfs/QmTmjXvJCisVUsHizdcin7VNAQc5arRZphL2f9ALNuH2F7\"]},\"src/libraries/WalletLib.sol\":{\"keccak256\":\"0xcd683a9161bc4c17220d606569729ddc5047cc22c3197e2e5e3130aac488e0f2\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://8096a63d894b255d64d4151ae9edf935c0c2e21a637613f6c068cce4c03008c4\",\"dweb:/ipfs/QmQHHxFJmYD5DGVXLz1kHwwBzF1J5D5wLnod7KzcTi5Ts5\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"OnlyAdmin()":[{"notice":"Thrown when the caller does not have the admin role."}],"ZeroAddress()":[{"notice":"Thrown when the zero address is provided where a non-zero address is required."}],"OnlyOperator()":[{"notice":"Thrown when the caller does not have the operator role."}],"OnlyLegacyDeployer()":[{"notice":"Thrown when the caller does not have the legacy-deployer role."}],"ArrayLengthMismatch()":[{"notice":"Thrown when paired input arrays have mismatched lengths."}],"InvalidTimelockDelay()":[{"notice":"Thrown when the provided timelock delay is zero or exceeds the maximum."}],"ImplementationNotDeployed()":[{"notice":"Thrown when a deploy target (the beacon, its resolved implementation, or the         legacy implementation) has no code."}],"ImplementationNotAuthorized()":[{"notice":"Thrown when an implementation has not been authorized."}]},"events":{"TimelockDelaySet(uint256)":{"notice":"Emitted when the timelock delay is updated."},"ImplementationSet(address)":{"notice":"Emitted when the default wallet implementation is updated."},"ImplementationAuthorized(address)":{"notice":"Emitted when a wallet implementation is added to the authorized set."},"ImplementationUnauthorized(address)":{"notice":"Emitted when a wallet implementation is removed from the authorized set."},"WalletDeployed(address,address,bytes32,address)":{"notice":"Emitted when a new deposit wallet is deployed."}},"notice":"Factory contract for deploying and managing DepositWallets. Deploys ERC-1967         beacon proxies going forward, and can also deploy legacy ERC-1967 (UUPS-shaped)         wallets at the exact deterministic addresses the pre-beacon factory used.","methods":{"BEACON()":{"notice":"The beacon that resolves the implementation for beacon-shape wallets."},"LEGACY_IMPL()":{"notice":"The implementation embedded in legacy-shape (ERC-1967, UUPS) wallets."},"timelockDelay()":{"notice":"The delay in seconds that must elapse after pausing before the owner can         execute paused-only operations on a wallet."},"implementation()":{"notice":"Legacy default wallet implementation pointer."},"isAdmin(address)":{"notice":"Returns whether the given address has the admin role."},"addAdmin(address)":{"notice":"Grants the admin role to an address."},"isOperator(address)":{"notice":"Returns whether the given address has the operator role."},"MAX_TIMELOCK_DELAY()":{"notice":"The maximum allowed timelock delay (7 days)."},"addOperator(address)":{"notice":"Grants the operator role to an address."},"removeAdmin(address)":{"notice":"Removes the admin role from an address."},"removeOperator(address)":{"notice":"Removes the operator role from an address."},"isLegacyDeployer(address)":{"notice":"Returns whether the given address has the legacy-deployer role."},"setTimelockDelay(uint256)":{"notice":"Sets the timelock delay for paused wallet operations."},"addLegacyDeployer(address)":{"notice":"Grants the legacy-deployer role to an address."},"setImplementation(address)":{"notice":"Sets the legacy slot-0 implementation pointer."},"deploy(address[],bytes32[])":{"notice":"Deploys one or more beacon-shape deposit wallets with deterministic addresses."},"predictWalletAddress(bytes32)":{"notice":"Predicts the deterministic address of a beacon-proxy wallet before deployment."},"removeLegacyDeployer(address)":{"notice":"Removes the legacy-deployer role from an address."},"authorizeImplementation(address)":{"notice":"Authorizes an implementation address for legacy UUPS upgrades."},"authorizedImplementation(address)":{"notice":"Tracks which implementation addresses are authorized for legacy UUPS upgrades."},"deployLegacy(address[],bytes32[])":{"notice":"Deploys one or more legacy-shape (ERC-1967, UUPS) deposit wallets with         deterministic addresses that match the pre-beacon factory's derivation."},"unauthorizeImplementation(address)":{"notice":"Removes an implementation address from the authorized set."},"initialize(address,address,uint256)":{"notice":"Initializes the factory with an owner, admin, and timelock delay."},"predictLegacyWalletAddress(bytes32)":{"notice":"Predicts the deterministic address of a legacy-shape (ERC-1967) wallet before         deployment."},"predictWalletAddress(address,bytes32)":{"notice":"Predicts the deterministic address of a wallet before deployment."},"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])":{"notice":"Proxies batch execution to one or more wallets."}},"version":1},"devdoc":{"kind":"dev","title":"DepositWalletFactory","author":"Polymarket","errors":{"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"UpgradeFailed()":[{"details":"The upgrade failed."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"UnauthorizedCallContext()":[{"details":"The call is from an unauthorized call context."}],"ImplementationNotDeployed()":[{"details":"Fail-closed guard: deploying a proxy whose implementation/beacon is code-less would      let `initialize` silently succeed as a delegatecall to an empty account, minting an      ownerless wallet that anyone could later seize."}],"ImplementationNotAuthorized()":[{"details":"Deprecated post-migration; only thrown by the legacy {setImplementation} surface."}]},"events":{"Upgraded(address)":{"details":"Emitted when the proxy's implementation is upgraded."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized."},"TimelockDelaySet(uint256)":{"params":{"timelockDelay":"The new timelock delay in seconds."}},"ImplementationSet(address)":{"params":{"Implementation":"The address of the new default implementation."},"details":"Deprecated; the legacy slot-0 `implementation` pointer is no longer consulted by      {DepositWalletFactory.deploy}."},"RolesUpdated(address,uint256)":{"details":"The `user`'s roles is updated to `roles`. Each bit of `roles` represents whether the role is set."},"ImplementationAuthorized(address)":{"params":{"implementation":"The address of the authorized implementation."},"details":"Deprecated post-migration; only emitted while the legacy upgrade surface is in use      (e.g., authorizing {BeaconForwarder})."},"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"ImplementationUnauthorized(address)":{"params":{"implementation":"The address of the unauthorized implementation."},"details":"Deprecated post-migration; only emitted while the legacy upgrade surface is in use."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"WalletDeployed(address,address,bytes32,address)":{"params":{"id":"The unique identifier assigned to the wallet.","owner":"The initial owner of the wallet.","wallet":"The address of the newly deployed wallet proxy.","implementation":"The address embedded in the proxy: the beacon for beacon-shape                       wallets, or the legacy implementation for legacy-shape wallets."}}},"details":"Uses a four-tier role model:      - **Owner**: can add/remove admins, manage implementations, and authorize UUPS upgrades                   of the factory itself.      - **Admin** (ROLE_0): can add/remove operators and legacy deployers, and configure the                   timelock delay.      - **Operator** (ROLE_1): can deploy beacon-shape wallets and proxy batch executions.      - **Legacy deployer** (ROLE_2): can deploy legacy-shape wallets via {deployLegacy}.      Two deploy paths, fed identical `args`/`salt`:      - {deploy} produces an ERC-1967 beacon proxy bound to {BEACON}.      - {deployLegacy} produces a plain ERC-1967 proxy embedding {LEGACY_IMPL}. This reproduces        the exact addresses the pre-beacon factory derived, because the address depends only on        (this factory's address, the embedded implementation, the Solady proxy template, the        id) — never on this factory's own bytecode. It exists for ids whose legacy address has        already been handed out, and for cross-chain recovery: deployed at the canonical        factory address on another chain, it mints a wallet at the identical address a user's        Polygon deposit wallet occupies.      Both paths fail closed: they revert unless the embedded implementation/beacon already      holds code, so a misordered rollout cannot mint ownerless, seizable wallets.      Storage slots 0/1/2 (`implementation`, `timelockDelay`, `authorizedImplementation`) are      preserved from prior versions so this contract can be installed as a UUPS upgrade on the      live factory proxy without corrupting state.","methods":{"owner()":{"details":"Returns the owner of the contract."},"constructor":{"params":{"_beacon":"The beacon contract address for beacon-shape wallets.","_legacyImpl":"The legacy implementation address embedded in legacy-shape wallets."},"details":"Sets the beacon and legacy implementation, then disables initializers on the      implementation contract."},"proxiableUUID()":{"details":"Returns the storage slot used by the implementation, as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822). Note: The `notDelegated` modifier prevents accidental upgrades to an implementation that is a proxy contract."},"isAdmin(address)":{"params":{"_admin":"The address to check."},"returns":{"_0":"True if the address is an admin."}},"rolesOf(address)":{"details":"Returns the roles of `user`."},"addAdmin(address)":{"params":{"_admin":"The address to grant the admin role."}},"isOperator(address)":{"params":{"_operator":"The address to check."},"returns":{"_0":"True if the address is an operator."}},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"addOperator(address)":{"params":{"_operator":"The address to grant the operator role."}},"removeAdmin(address)":{"params":{"_admin":"The address to remove the admin role from."}},"renounceRoles(uint256)":{"details":"Allow the caller to remove their own roles. If the caller does not have a role, then it will be an no-op for the role."},"removeOperator(address)":{"params":{"_operator":"The address to remove the operator role from."}},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"isLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to check."},"returns":{"_0":"True if the address is a legacy deployer."}},"setTimelockDelay(uint256)":{"params":{"_timelockDelay":"The new timelock delay in seconds."}},"addLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to grant the legacy-deployer role."}},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"setImplementation(address)":{"params":{"_implementation":"The new default implementation address."},"details":"Deprecated; retained for ABI compatibility. Has no effect on {deploy} (which uses      {BEACON}) or {deployLegacy} (which uses {LEGACY_IMPL})."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"deploy(address[],bytes32[])":{"params":{"_ids":"The unique identifiers for each wallet.","_owners":"The initial owner addresses for each wallet."},"details":"It is the operator's responsibility to ensure that each `_id` is unique.      Duplicate IDs will cause the deployment to revert because the deterministic      address is already occupied. Note: beacon-shape and legacy-shape wallets for the      same `_id` live at DIFFERENT addresses (different proxy template), so they never      collide; the operator must dedupe IDs across both shapes off-chain."},"grantRoles(address,uint256)":{"details":"Allows the owner to grant `user` `roles`. If the `user` already has a role, then it will be an no-op for the role."},"hasAnyRole(address,uint256)":{"details":"Returns whether `user` has any of `roles`."},"hasAllRoles(address,uint256)":{"details":"Returns whether `user` has all of `roles`."},"revokeRoles(address,uint256)":{"details":"Allows the owner to remove `user` `roles`. If the `user` does not have a role, then it will be an no-op for the role."},"predictWalletAddress(bytes32)":{"params":{"_id":"The unique identifier for the wallet."},"details":"This returns the address derived from the beacon-proxy template. For the address of a      legacy-shape (ERC-1967, UUPS) wallet, use {predictLegacyWalletAddress} — the two      shapes live at different deterministic addresses because the proxy bytecode (and      therefore the CREATE2 derivation) differs.","returns":{"_0":"The predicted beacon-proxy wallet address."}},"removeLegacyDeployer(address)":{"params":{"_legacyDeployer":"The address to remove the legacy-deployer role from."}},"upgradeToAndCall(address,bytes)":{"details":"Upgrades the proxy's implementation to `newImplementation`. Emits a {Upgraded} event. Note: Passing in empty `data` skips the delegatecall to `newImplementation`."},"authorizeImplementation(address)":{"params":{"_implementation":"The implementation address to authorize."},"details":"Used during the migration window to authorize {BeaconForwarder}; will be deprecated      after the migration window closes."},"deployLegacy(address[],bytes32[])":{"params":{"_ids":"The unique identifiers for each wallet.","_owners":"The initial owner addresses for each wallet."},"details":"Restricted to the legacy-deployer role (ROLE_2), granted independently of the      operator role. Used for ids whose legacy address has already been handed out, and for      cross-chain recovery: a wallet deployed here lands at the same address the user's      Polygon deposit wallet occupies. The resulting wallet runs {LEGACY_IMPL} (the V1      implementation). See {deploy} for the ID-uniqueness and cross-shape notes."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"unauthorizeImplementation(address)":{"params":{"_implementation":"The implementation address to unauthorize."},"details":"Used during the migration window; will be deprecated after the window closes."},"initialize(address,address,uint256)":{"params":{"_admin":"The address to grant the initial admin role.","_owner":"The address to set as the factory owner.","_timelockDelay":"The initial timelock delay in seconds."}},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"predictLegacyWalletAddress(bytes32)":{"params":{"_id":"The unique identifier for the wallet."},"details":"This matches the address the pre-beacon factory assigned to a wallet with the same      `_id` — including, on other chains, the address of the user's Polygon wallet —      enabling cross-chain recovery at the identical address.","returns":{"_0":"The predicted legacy wallet address."}},"predictWalletAddress(address,bytes32)":{"params":{"_id":"The unique identifier for the wallet."},"details":"Deprecated; retained for ABI compatibility. The first argument is ignored — wallets      are now beacon proxies bound to {BEACON}. Prefer {predictWalletAddress(bytes32)}.","returns":{"_0":"The predicted wallet proxy address."}},"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])":{"params":{"_batches":"The batches to execute.","_signatures":"The corresponding signatures for each batch."},"details":"Each batch is forwarded to its target wallet's `execute` function. Works for both      wallet shapes (the `Batch` layout is identical across the legacy and current      implementations)."}},"version":1,"stateVariables":{"LEGACY_IMPL":{"details":"Set to the live legacy DepositWallet implementation so {deployLegacy} reproduces the      exact wallet addresses the pre-beacon factory deployed."},"implementation":{"details":"Deprecated; not consulted by {deploy} or {deployLegacy}. Retained only to preserve      slot 0 of the live factory proxy so this contract can be installed via UUPS upgrade      in place."},"authorizedImplementation":{"details":"Legacy-shape wallets gate their `upgrade` self-call on this mapping. Used during the      migration window to authorize {BeaconForwarder} so existing UUPS wallets can opt into      the beacon. Will be deprecated after the migration window closes."}}},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":4137,"label":"implementation","offset":0,"contract":"src/DepositWalletFactory.sol:DepositWalletFactory"},{"slot":"1","type":"t_uint256","astId":4140,"label":"timelockDelay","offset":0,"contract":"src/DepositWalletFactory.sol:DepositWalletFactory"},{"slot":"2","type":"t_mapping(t_address,t_bool)","astId":4145,"label":"authorizedImplementation","offset":0,"contract":"src/DepositWalletFactory.sol:DepositWalletFactory"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"6043:17293:6:-:0;;;1279:4:2;1220:66;;8692:278:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;8760:21:6;;8752:52;;;;-1:-1:-1;;;8752:52:6;;;;;;;;;;;;-1:-1:-1;;;;;8822:25:6;;8814:56;;;;-1:-1:-1;;;8814:56:6;;;;;;;;;;;;-1:-1:-1;;;;;8880:16:6;;;;;8906:25;;;;8941:22;:20;:22::i;:::-;8692:278;;6043:17293;;7121:737:3;-1:-1:-1;;7297:8:3;;7328:1;7321:9;;7318:134;;;7362:10;7356:4;7349:24;7433:4;7427;7420:18;7318:134;-1:-1:-1;;;;;7537:9:3;7533:1;7530;7526:9;7523:24;7513:329;;7665:9;7662:1;7658:17;7655:1;7648:28;7755:9;7749:4;7742:23;7799:28;7793:4;7787;7782:46;7513:329;;;7274:578;7121:737::o;14:177:10:-;93:13;;-1:-1:-1;;;;;135:31:10;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;:::-;6043:17293:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"6043:17293:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12741:125;;;;;;;;;;-1:-1:-1;12741:125:6;;;;;:::i;:::-;;:::i;:::-;;;421:42:10;409:55;;;391:74;;379:2;364:18;12741:125:6;;;;;;;;16022:327;;;;;;;;;;-1:-1:-1;16022:327:6;;;;;:::i;:::-;;:::i;:::-;;20049:102;;;;;;;;;;-1:-1:-1;20049:102:6;;;;;:::i;:::-;;:::i;9438:359::-;;;;;;;;;;-1:-1:-1;9438:359:6;;;;;:::i;:::-;;:::i;10291:109:1:-;;;;;;:::i;:::-;;:::i;9752:123::-;;;;;;:::i;:::-;;:::i;11342:139::-;;;;;;;;;;-1:-1:-1;11342:139:1;;;;;:::i;:::-;10933:15;10927:4;10920:29;;;11421:4;10962:18;;;;11062:4;11046:21;;;11040:28;11444:21;;:30;;11342:139;;;;3391:14:10;;3384:22;3366:41;;3354:2;3339:18;11342:139:1;3226:187:10;19136:129:6;;;;;;;;;;-1:-1:-1;19136:129:6;;;;;:::i;:::-;;:::i;12045:134::-;;;;;;;;;;-1:-1:-1;12045:134:6;;;;;:::i;:::-;;:::i;10904:113::-;;;;;;;;;;-1:-1:-1;10904:113:6;;;;;:::i;:::-;;:::i;9021:617:0:-;;;:::i;21395:204:6:-;;;;;;;;;;-1:-1:-1;21395:204:6;;;;;:::i;:::-;;:::i;7553:51::-;;;;;;;;;;;;7598:6;7553:51;;;;;3936:25:10;;;3924:2;3909:18;7553:51:6;3790:177:10;10731:353:1;;;;;;;;;;-1:-1:-1;10731:353:1;;;;;:::i;:::-;10933:15;10927:4;10920:29;;;10791:13;10962:18;;;;11062:4;11046:21;;11040:28;;10731:353;18855:125:6;;;;;;;;;;-1:-1:-1;18855:125:6;;;;;:::i;:::-;;:::i;7877:31::-;;;;;;;;;;;;;;;10020:125:1;;;;;;:::i;:::-;;:::i;3586:1618:5:-;;;;;;:::i;:::-;;:::i;11146:134:1:-;;;;;;;;;;-1:-1:-1;11146:134:1;;;;;:::i;:::-;10933:15;10927:4;10920:29;;;11224:4;10962:18;;;;11062:4;11046:21;;;11040:28;11247:21;:26;;;11146:134;3153:227:5;;;;;;;;;;;;;:::i;7250:56:6:-;;;;;;;;;;-1:-1:-1;7250:56:6;;;;;:::i;:::-;;;;;;;;;;;;;;;;9720:456:0;;;:::i;6659:29:6:-;;;;;;;;;;-1:-1:-1;6659:29:6;;;;;;;;11195:122;;;;;;;;;;-1:-1:-1;11195:122:6;;;;;:::i;:::-;;:::i;19824:98::-;;;;;;;;;;-1:-1:-1;19824:98:6;;;;;:::i;:::-;;:::i;8762:100:0:-;;;:::i;14502:1114:6:-;;;;;;;;;;-1:-1:-1;14502:1114:6;;;;;:::i;:::-;;:::i;20880:269::-;;;;;;;;;;-1:-1:-1;20880:269:6;;;;;:::i;:::-;;:::i;13365:282::-;;;;;;;;;;-1:-1:-1;13365:282:6;;;;;:::i;:::-;;:::i;11514:140::-;;;;;;;;;;-1:-1:-1;11514:140:6;;;;;:::i;:::-;;:::i;11408:182:0:-;;;;;;;;;;-1:-1:-1;11562:11:0;11556:18;11408:182;;18354:107:6;;;;;;;;;;-1:-1:-1;18354:107:6;;;;;:::i;:::-;;:::i;8168:36::-;;;;;;;;;;;;;;;18597:111;;;;;;;;;;-1:-1:-1;18597:111:6;;;;;:::i;:::-;;:::i;19406:119::-;;;;;;;;;;-1:-1:-1;19406:119:6;;;;;:::i;:::-;;:::i;20455:123::-;;;;;;;;;;-1:-1:-1;20455:123:6;;;;;:::i;:::-;;:::i;6844:28::-;;;;;;;;;;;;;;;;17311:735;;;;;;;;;;-1:-1:-1;17311:735:6;;;;;:::i;:::-;;:::i;10363:708:0:-;;;;;;:::i;:::-;;:::i;8348:349::-;;;;;;:::i;:::-;;:::i;11693:435::-;;;;;;;;;;-1:-1:-1;11693:435:0;;;;;:::i;:::-;11963:19;11957:4;11950:33;;;11812:14;11996:26;;;;12106:4;12090:21;;12084:28;;11693:435;12741:125:6;12807:7;12833:26;12855:3;12833:21;:26::i;:::-;12826:33;12741:125;-1:-1:-1;;12741:125:6:o;16022:327::-;10933:15:1;10927:4;10920:29;;;10293:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12847:6;11247:21;10274:56:6;;;;;;;;;;;;;;;;;16134:37;;::::1;16126:69;;;;;;;;;;;;;;;;;16210:9;16205:138;16221:19:::0;;::::1;16205:138;;;16276:8;;16285:1;16276:11;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:18;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;16261:42;;;16304:8;;16313:1;16304:11;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;16317;;16329:1;16317:14;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;16261:71;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16242:3;;;;;16205:138;;;;16022:327:::0;;;;:::o;20049:102::-;12517:13:0;:11;:13::i;:::-;20115:29:6::1;20128:6;12799::1;20115:12:6;:29::i;:::-;20049:102:::0;:::o;9438:359::-;2002:66:3;3769:8;;3867:1;3857:12;;3951:398;;;;4111:1;4107;4104;4100:9;4097:16;4085:9;4073:22;4070:44;4060:189;;4151:10;4145:4;4138:24;4226:4;4220;4213:18;4060:189;4288:1;4284;4279:3;4275:11;4271:19;4266:24;;3951:398;-1:-1:-1;9573:20:6::1;::::0;::::1;9565:51;;;;;;;;;;;;;;;;;9634:20;::::0;::::1;9626:51;;;;;;;;;;;;;;;;;9687:24;9704:6;9687:16;:24::i;:::-;9721:26;9731:6;12799::1;9721:9:6;:26::i;:::-;9757:33;9775:14;9757:17;:33::i;:::-;4448:1:3::0;4445:264;;;4549:1;4546;4539:12;4630:1;4624:4;4617:15;4666:28;4660:4;4654;4649:46;4445:264;4431:288;9438:359:6;;;:::o;10291:109:1:-;10362:31;10375:10;10387:5;10362:12;:31::i;9752:123::-;12517:13:0;:11;:13::i;:::-;9844:24:1::1;9856:4;9862:5;9844:11;:24::i;:::-;9752:123:::0;;:::o;19136:129:6:-;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;19220:38:::1;19233:15;12895:6:1;19220:12:6;:38::i;12045:134::-:0;12120:7;12146:26;12168:3;12146:21;:26::i;:::-;12139:33;12045:134;-1:-1:-1;;;12045:134:6:o;10904:113::-;10933:15:1;10927:4;10920:29;;;10960:4:6;10962:18:1;;;11062:4;11046:21;;;11040:28;12799:6;11247:21;:26;;10983:27:6;11146:134:1;9021:617:0;9114:15;7972:9;9132:46;;:15;:46;9114:64;;9346:19;9340:4;9333:33;9396:8;9390:4;9383:22;9452:7;9445:4;9439;9429:21;9422:38;9599:8;9552:45;9549:1;9546;9541:67;9248:374;9021:617::o;21395:204:6:-;12517:13:0;:11;:13::i;:::-;21484:41:6::1;::::0;::::1;21528:5;21484:41:::0;;;:24:::1;:41;::::0;;;;;:49;;;::::1;::::0;;21549:43;::::1;::::0;21528:5;21549:43:::1;21395:204:::0;:::o;18855:125::-;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;18936:37:::1;18948:15;12895:6:1;18936:11:6;:37::i;10020:125:1:-:0;12517:13:0;:11;:13::i;:::-;10113:25:1::1;10126:4;10132:5;10113:12;:25::i;3586:1618:5:-:0;3720:17:2;:15;:17::i;:::-;3739:36:5::1;3757:17;3739;:36::i;:::-;3888:17;3884:2;3880:26;3876:2;3872:35;3851:56;;3958:16;3952:4;3945:30;4001:10;3995:4;3988:24;4056:28;4261:1;4253:4;4247;4241;4235;4216:17;4209:5;4198:60;4192:67;4189:74;4179:199;;4296:10;4290:4;4283:24;4359:4;4353;4346:18;4179:199;4483:17;4456:25;4450:4;4438:10;4433:68;4514:28:::0;;;4672:516;::::1;;;4800:4;4794:11;4851;4838;4835:1;4822:41;4957:4;4945:10;4932:11;4929:1;4910:17;4903:5;4890:72;4880:294;;5091:16;5085:4;5082:1;5067:41;5139:16;5136:1;5129:27;4672:516;3586:1618:::0;;;:::o;3153:227::-;3220:7;3930:20:2;:18;:20::i;:::-;-1:-1:-1;2188:66:5::1;3153:227:::0;:::o;9720:456:0:-;9922:19;9916:4;9909:33;9968:8;9962:4;9955:22;10020:1;10013:4;10007;9997:21;9990:32;10151:8;10105:44;10102:1;10099;10094:66;9720:456::o;11195:122:6:-;10933:15:1;10927:4;10920:29;;;11257:4:6;10962:18:1;;;11062:4;11046:21;;;11040:28;12847:6;11247:21;:26;;11280:30:6;11146:134:1;19824:98:6;12517:13:0;:11;:13::i;:::-;19887:28:6::1;19899:6;12799::1;19887:11:6;:28::i;8762:100:0:-:0;12517:13;:11;:13::i;:::-;8834:21:::1;8852:1;8834:9;:21::i;:::-;8762:100::o:0;14502:1114:6:-;10933:15:1;10927:4;10920:29;;;10293:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12847:6;11247:21;10274:56:6;;;;;;;;;;;;;;;;;14611:29;;::::1;14603:61;;;;;;;;;;;;;;;;;15073:6;:18;;;15095:1;15073:23:::0;15065:61:::1;;;;;;;;;;;;;;;;;15152:6;15144:30;;;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;;;15192:1;15144:49:::0;15136:87:::1;;;;;;;;;;;;;;;;;15239:9;15234:376;15250:18:::0;;::::1;15234:376;;;15289:17;15328:4;15335;;15340:1;15335:7;;;;;;;:::i;:::-;;;;;;;15309:34;;;;;;;;10890:42:10::0;10878:55;;;;10860:74;;10965:2;10950:18;;10943:34;10848:2;10833:18;;10686:297;15309:34:6::1;;;;;;;;;;;;;15289:54;;15358:14;15391:77;15438:6;15446:4;15462;15452:15;;;;;;15391:46;:77::i;:::-;15358:110;;15498:6;15483:33;;;15517:7;;15525:1;15517:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;15483:45;::::0;;::::1;::::0;;;;;;421:42:10;409:55;;;15483:45:6::1;::::0;::::1;391:74:10::0;364:18;;15483:45:6::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15583:4;;15588:1;15583:7;;;;;;;:::i;:::-;;;;;;;15571;;15579:1;15571:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;15548:51;::::0;::::1;15592:6;409:55:10::0;;391:74;;15548:51:6;;::::1;::::0;;::::1;::::0;::::1;::::0;379:2:10;364:18;15548:51:6::1;;;;;;;-1:-1:-1::0;;15270:3:6::1;;15234:376;;20880:269:::0;12517:13:0;:11;:13::i;:::-;20975:29:6::1;::::0;::::1;20967:60;;;;;;;;;;;;;;;;;21037:41;::::0;::::1;;::::0;;;:24:::1;:41;::::0;;;;;:48;;;::::1;21081:4;21037:48;::::0;;21101:41;::::1;::::0;21037;21101::::1;20880:269:::0;:::o;13365:282::-;13476:30;;;13495:4;13476:30;;;10860:74:10;10950:18;;;10943:34;;;13437:7:6;;;;10833:18:10;;13476:30:6;;;;;;;;;;;;13456:50;;13524:116;13581:11;13594:4;13610;13600:15;;;;;;13625:4;13524:43;:116::i;11514:140::-;10933:15:1;10927:4;10920:29;;;11588:4:6;10962:18:1;;;11062:4;11046:21;;;11040:28;12895:6;11247:21;:26;;11611:36:6;11146:134:1;18354:107:6;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;18423:31:::1;18435:9;12847:6:1;18423:11:6;:31::i;18597:111::-:0;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;18669:32:::1;18682:9;12847:6:1;18669:12:6;:32::i;19406:119::-:0;10933:15:1;10927:4;10920:29;;;10106:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12799:6;11247:21;10087:53:6;;;;;;;;;;;;;;;;;19485:33:::1;19503:14;19485:17;:33::i;20455:123::-:0;12517:13:0;:11;:13::i;:::-;20536:35:6::1;20555:15;20536:18;:35::i;17311:735::-:0;10933:15:1;10927:4;10920:29;;;10496:10:6;11224:4:1;10962:18;11062:4;11046:21;;11040:28;12895:6;11247:21;10477:62:6;;;;;;;;;;;;;;;;;17452:29;;::::1;17444:61;;;;;;;;;;;;;;;;;17612:11;:23;;;17639:1;17612:28:::0;17604:66:::1;;;;;;;;;;;;;;;;;17686:9;17681:359;17697:18:::0;;::::1;17681:359;;;17736:17;17775:4;17782;;17787:1;17782:7;;;;;;;:::i;:::-;;;;;;;17756:34;;;;;;;;10890:42:10::0;10878:55;;;;10860:74;;10965:2;10950:18;;10943:34;10848:2;10833:18;;10686:297;17756:34:6::1;;;;;;;;;;;;;17736:54;;17805:14;17822:71;17858:11;17871:4;17887;17877:15;;;;;;17822:35;:71::i;:::-;17805:88;;17923:6;17908:33;;;17942:7;;17950:1;17942:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;17908:45;::::0;;::::1;::::0;;;;;;421:42:10;409:55;;;17908:45:6::1;::::0;::::1;391:74:10::0;364:18;;17908:45:6::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18008:4;;18013:1;18008:7;;;;;;;:::i;:::-;;;;;;;17996;;18004:1;17996:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;17973:56;::::0;::::1;18017:11;409:55:10::0;;391:74;;17973:56:6;;::::1;::::0;;::::1;::::0;::::1;::::0;379:2:10;364:18;17973:56:6::1;;;;;;;-1:-1:-1::0;;17717:3:6::1;;17681:359;;10363:708:0::0;12517:13;:11;:13::i;:::-;10597:19:::1;10591:4;10584:33;10643:12;10637:4;10630:26;10705:4;10699;10689:21;10811:12;10805:19;10792:11;10789:36;10786:157;;;10857:10;10851:4;10844:24;10924:4;10918;10911:18;10786:157;11020:1;10999:23:::0;;11041::::1;11051:12:::0;11041:9:::1;:23::i;8348:349::-:0;12517:13;:11;:13::i;:::-;8520:8:::1;8516:2;8512:17;8502:150;;8562:10;8556:4;8549:24;8633:4;8627;8620:18;8502:150;8671:19;8681:8;8671:9;:19::i;23051:283:6:-:0;23157:30;;;23176:4;23157:30;;;10860:74:10;10950:18;;;10943:34;;;23118:7:6;;;;10833:18:10;;23157:30:6;;;;;;;;;;;;23137:50;;23205:122;23273:6;23281:4;23297;23287:15;;;;;;23312:4;23205:54;:122::i;7292:355:0:-;7504:11;7498:18;7488:8;7485:32;7475:156;;7550:10;7544:4;7537:24;7612:4;7606;7599:18;4468:117:1;4546:32;4559:4;4565:5;4572;4546:12;:32::i;4883:1190:0:-;5793:26;;5883:11;5876:29;;;5793:26;6031:1;5991:38;6031:1;;5980:63;4883:1190;:::o;2478:432:1:-;2632:15;2626:4;2619:29;2674:4;2668;2661:18;2758:5;2751:4;2745;2735:21;2728:36;2888:5;2880:4;2874:11;2870:2;2866:20;2834:30;2831:1;2828;2823:71;2478:432;;:::o;22598:256:6:-;22693:1;22676:14;:18;:58;;;;;7598:6;22698:14;:36;;22676:58;22668:91;;;;;;;;;;;;;;;;;22769:13;:30;;;22815:32;;3936:25:10;;;22815:32:6;;3924:2:10;3909:18;22815:32:6;;;;;;;;22598:256;:::o;4217:115:1:-;4294:31;4307:4;4313:5;4320:4;4294:12;:31::i;3017:123:2:-;2687:4;2661:6;:32;3076:57;;3101:32;:30;:32::i;21863:66:6:-;12517:13:0;:11;:13::i;3278:127:2:-;2687:4;2661:6;:32;3340:58;;3366:32;:30;:32::i;6145:1089:0:-;6857:11;7093:16;;6941:26;;;;;;;7053:38;7050:1;;7042:78;7177:27;6145:1089::o;114499:240:4:-;114629:16;114672:60;114710:1;114713:6;114721:4;114727;114672:37;:60::i;:::-;114661:71;114499:240;-1:-1:-1;;;;114499:240:4:o;61913:343::-;62093:17;62122:12;62137:41;62157:14;62173:4;62137:19;:41::i;:::-;62122:56;;62200:49;62228:4;62234;62240:8;62200:27;:49::i;:::-;62188:61;61913:343;-1:-1:-1;;;;;;61913:343:4:o;22205:252:6:-;22285:41;;;;;;;:24;:41;;;;;;;;22277:81;;;;;;;;;;;;;;;;;22368:14;:32;;;;;;;;;;;;;22416:34;;391:74:10;;;22416:34:6;;379:2:10;364:18;22416:34:6;245:226:10;55028:234:4;55155:16;55198:57;55225:1;55228:14;55244:4;55250;55198:26;:57::i;121466:349::-;121649:17;121678:12;121693:44;121724:6;121732:4;121693:30;:44::i;3116:967:1:-;3282:15;3276:4;3269:29;3324:4;3318;3311:18;3374:4;3368;3358:21;3452:8;3446:15;3559:5;3550:7;3547:18;3803:2;3793:62;;-1:-1:-1;3833:19:1;;;3820:33;;3793:62;3927:7;3917:8;3910:25;4059:7;4051:4;4045:11;4041:2;4037:20;4005:30;4002:1;3999;3994:73;;;;3116:967;;;:::o;4257:234:2:-;4401:10;4395:4;4388:24;4470:4;4464;4457:18;114883:1125:4;115050:16;115159:4;115153:11;115192:4;115186:11;115269:1;115262:4;115259:1;115255:12;115252:1;115245:4;115239;115235:15;115232:1;115225:5;115214:57;115210:62;115306:66;115299:4;115296:1;115292:12;115285:88;115407:66;115400:4;115397:1;115393:12;115386:88;115508:48;115501:4;115498:1;115494:12;115487:70;115591:6;115584:4;115581:1;115577:12;115570:28;115766:1;115762:2;115758:10;115732:24;115728:41;115718:6;115715:1;115712:13;115709:1;115705:21;115698:72;115838:4;115831;115828:1;115824:12;115817:4;115814:1;115810:12;115803:5;115795:48;115783:60;;;;115866:8;115856:136;;115907:10;115901:4;115894:24;115973:4;115967;115960:18;60678:1026;60797:12;60906:4;60900:11;60939:4;60933:11;61101:6;61098:1;61095:13;61077:16;61059;61044:65;61137:1;61122:142;61147:1;61144;61141:8;61122:142;;;61239:4;61225:23;;;;;61219:30;61208:4;61197:20;;;;61190:60;61157:12;61122:142;;;61126:14;61298:66;61291:4;61288:1;61284:12;61277:88;61399:66;61392:4;61389:1;61385:12;61378:88;61492:6;61486:4;61479:20;61525:14;61519:4;61512:28;61602:1;61598:2;61594:10;61570:22;61566:39;61560:4;61553:53;61635:4;61629:11;61626:1;61619:22;61682:4;61679:1;61675:12;61672:1;61662:26;61654:34;;;;60678:1026;;;;:::o;154939:578::-;155069:17;155234:4;155228;155220:19;-1:-1:-1;155280:4:4;155273:18;;;155321:2;155317:17;155311:4;155304:31;155355:4;155348:18;155408:4;155402;155392:21;;;155426:15;;155392:21;154939:578::o;55417:1088::-;55581:16;55690:4;55684:11;55723:4;55717:11;55800:1;55793:4;55790:1;55786:12;55783:1;55776:4;55770;55766:15;55763:1;55756:5;55745:57;55741:62;55837:66;55830:4;55827:1;55823:12;55816:88;55938:66;55931:4;55928:1;55924:12;55917:88;56031:6;56025:4;56018:20;56064:14;56058:4;56051:28;56239:1;56235:2;56231:10;56205:24;56201:41;56192:6;56189:1;56186:13;56179:64;56272:4;56266:11;56263:1;56256:22;56335:4;56328;56325:1;56321:12;56318:1;56311:5;56303:37;56291:49;;;;56363:8;56353:136;;56404:10;56398:4;56391:24;56470:4;56464;56457:18;120214:1052;120336:12;120445:4;120439:11;120478:4;120472:11;120640:6;120637:1;120634:13;120616:16;120598;120583:65;120676:1;120661:142;120686:1;120683;120680:8;120661:142;;;120778:4;120764:23;;;;;120758:30;120747:4;120736:20;;;;120729:60;120696:12;120661:142;;;120665:14;120837:66;120830:4;120827:1;120823:12;120816:88;120938:66;120931:4;120928:1;120924:12;120917:88;121039:48;121032:4;121029:1;121025:12;121018:70;121122:6;121115:4;121112:1;121108:12;121101:28;121188:1;121184:2;121180:10;121156:22;121152:39;121149:1;121142:50;121244:4;121241:1;121237:12;121230:4;121227:1;121223:12;121213:37;121205:45;;;;120214:1052;;;;:::o;14:226:10:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;187:23:10;;14:226;-1:-1:-1;14:226:10:o;476:381::-;553:8;563:6;617:3;610:4;602:6;598:17;594:27;584:55;;635:1;632;625:12;584:55;-1:-1:-1;658:20:10;;701:18;690:30;;687:50;;;733:1;730;723:12;687:50;770:4;762:6;758:17;746:29;;830:3;823:4;813:6;810:1;806:14;798:6;794:27;790:38;787:47;784:67;;;847:1;844;837:12;784:67;476:381;;;;;:::o;862:832::-;1020:6;1028;1036;1044;1097:2;1085:9;1076:7;1072:23;1068:32;1065:52;;;1113:1;1110;1103:12;1065:52;1153:9;1140:23;1186:18;1178:6;1175:30;1172:50;;;1218:1;1215;1208:12;1172:50;1257:84;1333:7;1324:6;1313:9;1309:22;1257:84;:::i;:::-;1360:8;;-1:-1:-1;1231:110:10;-1:-1:-1;;1448:2:10;1433:18;;1420:32;1477:18;1464:32;;1461:52;;;1509:1;1506;1499:12;1461:52;1548:86;1626:7;1615:8;1604:9;1600:24;1548:86;:::i;:::-;862:832;;;;-1:-1:-1;1653:8:10;-1:-1:-1;;;;862:832:10:o;1699:154::-;1785:42;1778:5;1774:54;1767:5;1764:65;1754:93;;1843:1;1840;1833:12;1858:247;1917:6;1970:2;1958:9;1949:7;1945:23;1941:32;1938:52;;;1986:1;1983;1976:12;1938:52;2025:9;2012:23;2044:31;2069:5;2044:31;:::i;2110:508::-;2187:6;2195;2203;2256:2;2244:9;2235:7;2231:23;2227:32;2224:52;;;2272:1;2269;2262:12;2224:52;2311:9;2298:23;2330:31;2355:5;2330:31;:::i;:::-;2380:5;-1:-1:-1;2437:2:10;2422:18;;2409:32;2450:33;2409:32;2450:33;:::i;:::-;2110:508;;2502:7;;-1:-1:-1;;;2582:2:10;2567:18;;;;2554:32;;2110:508::o;2854:367::-;2922:6;2930;2983:2;2971:9;2962:7;2958:23;2954:32;2951:52;;;2999:1;2996;2989:12;2951:52;3038:9;3025:23;3057:31;3082:5;3057:31;:::i;:::-;3107:5;3185:2;3170:18;;;;3157:32;;-1:-1:-1;;;2854:367:10:o;3972:721::-;4051:6;4059;4067;4120:2;4108:9;4099:7;4095:23;4091:32;4088:52;;;4136:1;4133;4126:12;4088:52;4175:9;4162:23;4194:31;4219:5;4194:31;:::i;:::-;4244:5;-1:-1:-1;4300:2:10;4285:18;;4272:32;4327:18;4316:30;;4313:50;;;4359:1;4356;4349:12;4313:50;4382:22;;4435:4;4427:13;;4423:27;-1:-1:-1;4413:55:10;;4464:1;4461;4454:12;4413:55;4504:2;4491:16;4530:18;4522:6;4519:30;4516:50;;;4562:1;4559;4552:12;4516:50;4607:7;4602:2;4593:6;4589:2;4585:15;4581:24;4578:37;4575:57;;;4628:1;4625;4618:12;4575:57;3972:721;;4659:2;4651:11;;;;;-1:-1:-1;4681:6:10;;-1:-1:-1;;;3972:721:10:o;5681:184::-;5733:77;5730:1;5723:88;5830:4;5827:1;5820:15;5854:4;5851:1;5844:15;5870:381;5961:4;6019:11;6006:25;6109:66;6098:8;6082:14;6078:29;6074:102;6054:18;6050:127;6040:155;;6191:1;6188;6181:12;6040:155;6212:33;;;;;5870:381;-1:-1:-1;;5870:381:10:o;6256:580::-;6333:4;6339:6;6399:11;6386:25;6489:66;6478:8;6462:14;6458:29;6454:102;6434:18;6430:127;6420:155;;6571:1;6568;6561:12;6420:155;6598:33;;6650:20;;;-1:-1:-1;6693:18:10;6682:30;;6679:50;;;6725:1;6722;6715:12;6679:50;6758:4;6746:17;;-1:-1:-1;6789:14:10;6785:27;;;6775:38;;6772:58;;;6826:1;6823;6816:12;6841:325;6929:6;6924:3;6917:19;6981:6;6974:5;6967:4;6962:3;6958:14;6945:43;;7033:1;7026:4;7017:6;7012:3;7008:16;7004:27;6997:38;6899:3;7155:4;7085:66;7080:2;7072:6;7068:15;7064:88;7059:3;7055:98;7051:109;7044:116;;6841:325;;;;:::o;7171:1819::-;7254:3;7285;7309:6;7304:3;7297:19;7341:4;7336:3;7332:14;7325:21;;7399:4;7389:6;7386:1;7382:14;7375:5;7371:26;7367:37;7427:5;7450:1;7460:1504;7474:6;7471:1;7468:13;7460:1504;;;7557:66;7549:5;7543:4;7539:16;7535:89;7530:3;7523:102;7677:6;7664:20;7763:66;7755:5;7739:14;7735:26;7731:99;7711:18;7707:124;7697:152;;7845:1;7842;7835:12;7697:152;7877:30;;7935:21;;7969:33;7935:21;7969:33;:::i;:::-;8041:42;8028:56;8015:70;;8164:4;8151:18;;;8138:32;8190:15;;;8183:32;8282:4;8269:18;;8256:32;8345:14;8341:28;;;8371:66;8337:101;8311:128;;8301:156;;8453:1;8450;8443:12;8301:156;8485:34;8610:4;8597:18;;;8548:21;8644:18;8631:32;;8628:52;;;8676:1;8673;8666:12;8628:52;8729:8;8713:14;8709:29;8700:7;8696:43;8693:63;;;8752:1;8749;8742:12;8693:63;8793:4;8786;8780;8776:15;8769:29;8819:61;8874:4;8868;8864:15;8854:8;8845:7;8819:61;:::i;:::-;8915:4;8940:14;;;;8811:69;;-1:-1:-1;8903:17:10;;;;;-1:-1:-1;;7496:1:10;7489:9;7460:1504;;;-1:-1:-1;8980:4:10;;7171:1819;-1:-1:-1;;;;;;7171:1819:10:o;8995:1430::-;9228:2;9217:9;9210:21;9191:4;9266:6;9253:20;9282:31;9307:5;9282:31;:::i;:::-;9360:42;9349:54;9344:2;9329:18;;;9322:82;;;;9474:4;9462:17;;9449:31;9511:2;9496:18;;;9489:35;;;;9582:15;;;9569:29;9629:4;9614:20;;9607:37;9692:15;;9679:29;9759:14;9755:27;;;9784:66;9751:100;9727:125;;9717:153;;9866:1;9863;9856:12;9717:153;9894:31;;10006:4;9993:18;;;9948:21;10034:18;10023:30;;10020:50;;;10066:1;10063;10056:12;10020:50;10122:6;10119:1;10115:14;10099;10095:35;10086:7;10082:49;10079:69;;;10144:1;10141;10134:12;10079:69;10185:4;10179:3;10168:9;10164:19;10157:33;10210:88;10293:3;10282:9;10278:19;10270:6;10261:7;10210:88;:::i;:::-;10199:99;;;10345:9;10340:3;10336:19;10329:4;10318:9;10314:20;10307:49;10373:46;10415:3;10407:6;10399;10373:46;:::i;10430:251::-;10500:6;10553:2;10541:9;10532:7;10528:23;10524:32;10521:52;;;10569:1;10566;10559:12;10521:52;10601:9;10595:16;10620:31;10645:5;10620:31;:::i","linkReferences":{},"immutableReferences":{"1739":[{"start":6535,"length":32},{"start":6590,"length":32}],"4152":[{"start":1238,"length":32},{"start":3738,"length":32},{"start":3850,"length":32},{"start":4178,"length":32},{"start":4503,"length":32},{"start":6114,"length":32}],"4155":[{"start":1773,"length":32},{"start":4848,"length":32},{"start":5331,"length":32},{"start":5551,"length":32},{"start":5876,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"addAdmin(address)","signatureHash4":"0x70480275","signatureHash32":"0x7048027520ecbaa8947764cd502c5c78c2c53bbd902e06b108da1cbdf98c6fc4"},{"signature":"addLegacyDeployer(address)","signatureHash4":"0x41462ce4","signatureHash32":"0x41462ce490aff72409ca4ac57456dee13ec9140c6f9b6176ee294b9182dd5a62"},{"signature":"addOperator(address)","signatureHash4":"0x9870d7fe","signatureHash32":"0x9870d7fe5d112134c55844951dedf365363006d9c588db07c4c85af6322a0619"},{"signature":"authorizedImplementation(address)","signatureHash4":"0x5325ad3d","signatureHash32":"0x5325ad3d90edd2846170665a573aa556c3fc25ec04a468ab10a0dd300e94cc67"},{"signature":"authorizeImplementation(address)","signatureHash4":"0x8a8c3cb0","signatureHash32":"0x8a8c3cb089c1f045c91b3cdd285b6664653ad9f81259911d9b7459e63f34b668"},{"signature":"BEACON()","signatureHash4":"0x49493a4d","signatureHash32":"0x49493a4d3d09a5240b4e3e548a3df6d94dcdc600508262acd3042ce34f5c4aed"},{"signature":"cancelOwnershipHandover()","signatureHash4":"0x54d1f13d","signatureHash32":"0x54d1f13d76f000aa202485e9c4b750a3fb26985ca34157c621201e1375bcbfac"},{"signature":"completeOwnershipHandover(address)","signatureHash4":"0xf04e283e","signatureHash32":"0xf04e283ea4b43821701876734697fc3e4a42281d51fee656e5c166b741e6afde"},{"signature":"deploy(address[],bytes32[])","signatureHash4":"0x77835641","signatureHash32":"0x778356415b86d8eeeab7639a791724ca3aa34e21668b86ef017106ef1cee92be"},{"signature":"deployLegacy(address[],bytes32[])","signatureHash4":"0xef8493cd","signatureHash32":"0xef8493cdd1351dee284f2b667b2cdb5f6cc5b343a64400a614ab415da11db75e"},{"signature":"grantRoles(address,uint256)","signatureHash4":"0x1c10893f","signatureHash32":"0x1c10893f461f63f252e10c56a85269430215faa87a39bb51c35210c074a11e7b"},{"signature":"hasAllRoles(address,uint256)","signatureHash4":"0x1cd64df4","signatureHash32":"0x1cd64df4cae98af87b77c9e51dc4421c4ccc2b6cbf1e7c5d162783be9a0c3457"},{"signature":"hasAnyRole(address,uint256)","signatureHash4":"0x514e62fc","signatureHash32":"0x514e62fc2e1c7a00f25cc302cd9c048fa36880834d4154076574210b7520ecba"},{"signature":"implementation()","signatureHash4":"0x5c60da1b","signatureHash32":"0x5c60da1b04210c25e1974b6edfcf5bb7c7365b6a88c42319fcbd024464075cc2"},{"signature":"initialize(address,address,uint256)","signatureHash4":"0x1794bb3c","signatureHash32":"0x1794bb3cc9499902627bdddec8dfb16959d6b3181594d5337e44a5a478310e97"},{"signature":"isAdmin(address)","signatureHash4":"0x24d7806c","signatureHash32":"0x24d7806c8210893fd4f5a038a23c113ec71effbeec58af5ea65d577a431d4108"},{"signature":"isLegacyDeployer(address)","signatureHash4":"0x8c1c34c9","signatureHash32":"0x8c1c34c9a1b7916381b9cfc20e860dee6ae2d0a14a79f08749ef9803fc7516aa"},{"signature":"isOperator(address)","signatureHash4":"0x6d70f7ae","signatureHash32":"0x6d70f7aed2fef4fefe8becca5b6d4426a0b73b6d76820f010cf67171394e7337"},{"signature":"LEGACY_IMPL()","signatureHash4":"0x989fff14","signatureHash32":"0x989fff146038f37549aa6fa83beceefb195348ded9db149652357253833ff9df"},{"signature":"MAX_TIMELOCK_DELAY()","signatureHash4":"0x2a083ca3","signatureHash32":"0x2a083ca3fe8217298f2c2e56c0a944b321f3431682bee3135e38380fa3ac164c"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"ownershipHandoverExpiresAt(address)","signatureHash4":"0xfee81cf4","signatureHash32":"0xfee81cf4fcd7f51611a3bf33478e3ef123da30b6dfa31a0b2a6d1192ef3c7e02"},{"signature":"predictLegacyWalletAddress(bytes32)","signatureHash4":"0x8becfd88","signatureHash32":"0x8becfd88bcc59dfdd577ecb1fd42533c622d15eb247497f6dd5bec2d4ba75510"},{"signature":"predictWalletAddress(address,bytes32)","signatureHash4":"0x1f264778","signatureHash32":"0x1f264778e7c5da4a3bb793fb876fff2af0764152074ca6418b0193d910c1c998"},{"signature":"predictWalletAddress(bytes32)","signatureHash4":"0x04f1d3c7","signatureHash32":"0x04f1d3c78652ab6a9fb57a0b11375bd71926f27c7e33816cf661dcdfc2a6fae8"},{"signature":"proxiableUUID()","signatureHash4":"0x52d1902d","signatureHash32":"0x52d1902ddf94a87b87c42e6ab3aff7da3c30beb57dc65dd86cb2543522a55a4c"},{"signature":"proxy((address,uint256,uint256,(address,uint256,bytes)[])[],bytes[])","signatureHash4":"0x0a3c4405","signatureHash32":"0x0a3c4405b658684d0f6cba1e38c96fa27246923c78f0154442dd118fdaa135c4"},{"signature":"removeAdmin(address)","signatureHash4":"0x1785f53c","signatureHash32":"0x1785f53c768259a7ab38ed67e958aab075b56ff206e3d7f29ea4ca203d1a9774"},{"signature":"removeLegacyDeployer(address)","signatureHash4":"0x1d9ce1d1","signatureHash32":"0x1d9ce1d1fd8bb7242ede313f8583200518443251b57df8ff8ed01c1a2c24bb1a"},{"signature":"removeOperator(address)","signatureHash4":"0xac8a584a","signatureHash32":"0xac8a584a6e5048c284ac18eec51bafddd0a85a269169cc224591f73c6fa4fc3e"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"renounceRoles(uint256)","signatureHash4":"0x183a4f6e","signatureHash32":"0x183a4f6e050787d31803d45ca7607a80858ac7b59ef8fd89e648ca7654218f70"},{"signature":"requestOwnershipHandover()","signatureHash4":"0x25692962","signatureHash32":"0x25692962a9adba4272ff0251e0e6793c55bbf553e4476049416aa620e8960301"},{"signature":"revokeRoles(address,uint256)","signatureHash4":"0x4a4ee7b1","signatureHash32":"0x4a4ee7b191d777188ac9875eef0d02255efefa6d976b4caaf70686b87bede442"},{"signature":"rolesOf(address)","signatureHash4":"0x2de94807","signatureHash32":"0x2de9480765549dbe945d049408cd9de121fbf93a60bf1c63c9c20d6fc39a22f2"},{"signature":"setImplementation(address)","signatureHash4":"0xd784d426","signatureHash32":"0xd784d42657167decb506df7ff5fda304865ee6b4456effbd7ee1f83655b9c866"},{"signature":"setTimelockDelay(uint256)","signatureHash4":"0xaf267f8f","signatureHash32":"0xaf267f8f9947fb9b3b10a671ba8d034ceccf9433154b8a61f41f65ee64a78542"},{"signature":"timelockDelay()","signatureHash4":"0xeef09bad","signatureHash32":"0xeef09bad8a03f4545cf80ae995978e67d28edc213658be558ddf04b98d5831cd"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"unauthorizeImplementation(address)","signatureHash4":"0x25b5af6c","signatureHash32":"0x25b5af6c2ecd423048f11702076c0cfb5c9dc8aa5569b14febae9d23a6ec5ac4"},{"signature":"upgradeToAndCall(address,bytes)","signatureHash4":"0x4f1ef286","signatureHash32":"0x4f1ef2866b98625bdfefae89411f7a82754ac4089eff8e78c8832329a538337f"}],"event":[{"signature":"ImplementationAuthorized(address)","signatureHash4":"0x02b73c10","signatureHash32":"0x02b73c10eecb635def7b11d92c9d82870141a7b0623e1e43f6eeabf202f310a4"},{"signature":"ImplementationSet(address)","signatureHash4":"0xab64f92a","signatureHash32":"0xab64f92ab780ecbf4f3866f57cee465ff36c89450dcce20237ca7a8d81fb7d13"},{"signature":"ImplementationUnauthorized(address)","signatureHash4":"0x595b3b62","signatureHash32":"0x595b3b62b3cba6f524d35709e19e9500b32b8431c58140fa081442ca1b6c07f0"},{"signature":"Initialized(uint64)","signatureHash4":"0xc7f505b2","signatureHash32":"0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2"},{"signature":"OwnershipHandoverCanceled(address)","signatureHash4":"0xfa7b8eab","signatureHash32":"0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92"},{"signature":"OwnershipHandoverRequested(address)","signatureHash4":"0xdbf36a10","signatureHash32":"0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"RolesUpdated(address,uint256)","signatureHash4":"0x715ad5ce","signatureHash32":"0x715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe26"},{"signature":"TimelockDelaySet(uint256)","signatureHash4":"0xccbd249a","signatureHash32":"0xccbd249a1d0f1e2e065e09f062524aaa559476c9ec2e6c4783937ea8a16ee4dc"},{"signature":"Upgraded(address)","signatureHash4":"0xbc7cd75a","signatureHash32":"0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b"},{"signature":"WalletDeployed(address,address,bytes32,address)","signatureHash4":"0x7441de0a","signatureHash32":"0x7441de0ad639fe5d2bf1c22447715a0528b682385736bb40ae8dd92555eb8276"}],"error":[{"signature":"AlreadyInitialized()","signatureHash4":"0x0dc149f0","signatureHash32":"0x0dc149f07762891dbcea3fe72770f3d63a1863fc54b2f084e8c59ec476996927"},{"signature":"ArrayLengthMismatch()","signatureHash4":"0xa24a13a6","signatureHash32":"0xa24a13a6c9c749fdebc1ced0c54b040f90ec2bad4921a2449a09961f99596abe"},{"signature":"ImplementationNotAuthorized()","signatureHash4":"0x5a80dc56","signatureHash32":"0x5a80dc5679f7dd1c253f8c24acdaf319b6d75bd93fe303d9906beda4e9b5ee0c"},{"signature":"ImplementationNotDeployed()","signatureHash4":"0x5c0f897a","signatureHash32":"0x5c0f897a4474f5050b1c24f90336709eaacbf03ef77668acd67eb642ccfb5f6f"},{"signature":"InvalidInitialization()","signatureHash4":"0xf92ee8a9","signatureHash32":"0xf92ee8a957075833165f68c320933b1a1294aafc84ee6e0dd3fb178008f9aaf5"},{"signature":"InvalidTimelockDelay()","signatureHash4":"0xd7265699","signatureHash32":"0xd726569948586a683e32d44086d574bde0c23da5f90db627381198dca3d7d965"},{"signature":"NewOwnerIsZeroAddress()","signatureHash4":"0x7448fbae","signatureHash32":"0x7448fbae245b5163a637f61fac94c5376c3e155928452ce47ee52d8c1b99587a"},{"signature":"NoHandoverRequest()","signatureHash4":"0x6f5e8818","signatureHash32":"0x6f5e8818469c73d5be4a0d17c371cde64695907022629c1d064c895f98d466a6"},{"signature":"NotInitializing()","signatureHash4":"0xd7e6bcf8","signatureHash32":"0xd7e6bcf8597daa127dc9f0048d2f08d5ef140a2cb659feabd700beff1f7a8302"},{"signature":"OnlyAdmin()","signatureHash4":"0x47556579","signatureHash32":"0x4755657908452c0c0f6c223ef1b4c4141063f774fc60736f2f5dc9b5822e269c"},{"signature":"OnlyLegacyDeployer()","signatureHash4":"0xb087c846","signatureHash32":"0xb087c8466df469ce2e70a568d8ddbfae428f614c79da508ff697d4e6579709da"},{"signature":"OnlyOperator()","signatureHash4":"0x27e1f1e5","signatureHash32":"0x27e1f1e5af18306f4eb3e41acd1bcb674286700ed0a791d43176d711b8a5a959"},{"signature":"Unauthorized()","signatureHash4":"0x82b42900","signatureHash32":"0x82b4290015f7ec7256ca2a6247d3c2a89c4865c0e791456df195f40ad0a81367"},{"signature":"UnauthorizedCallContext()","signatureHash4":"0x9f03a026","signatureHash32":"0x9f03a026210d6e1d73a6bb286502827a91a864e6fb88b45d0431438ccf6f87f1"},{"signature":"UpgradeFailed()","signatureHash4":"0x55299b49","signatureHash32":"0x55299b49652ca9ce92a8bd64b03e77919c7a18398e35089bb02c00e739b87f18"},{"signature":"ZeroAddress()","signatureHash4":"0xd92e233d","signatureHash32":"0xd92e233df2717d4a40030e20904abd27b68fcbeede117eaaccbbdac9618c8c73"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"137","address":"0x528CC05EFac2B0d255e423272187efD41248aBd7"}