{"matchId":"43406194","creationMatch":null,"runtimeMatch":"match","verifiedAt":"2026-08-08T06:52:36Z","creationBytecode":{"onchainBytecode":null,"recompiledBytecode":"0x6080806040523460855763409feecd19546001811660785760011c6002600160401b0319016034575b613667908161008a8239f35b6002600160411b0363409feecd19556001600160401b0360209081527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29080a16028565b63f92ee8a95f526004601cfd5b5f80fdfe6080806040526004361015610012575f80fd5b5f3560e01c90816304dfe79d146124ce5750806306fdde03146124b3578063095ea7b31461243757806312d10c4a146123fa57806316f0115b146123d257806317fc70ee146123ad57806318160ddd14612388578063207d06361461230b57806323386469146122e457806323b872dd1461219a578063254800d41461217d5780632569296214612134578063313ce567146121195780633644e515146120b7578063366a41201461209757806337bdc99b1461207a5780633a46b1a814611f535780633c130d9014611ec157806342966c6814611cff5780634bf5d7e914611ca85780634c86979514611bee57806353c7efa914611bd157806354d1f13d14611b8d578063587cde1e14611b585780635c19a95c14611b365780636d3cbe2114611aeb5780636f503e6714611a9e57806370a0823114611a6c578063715018a6146119fb57806376a82342146119bd5780637ecebe001461198b578063800f57cb146119665780638071cdfa14610ebf57806384a0e08214610e3f5780638902653814610dfd5780638da5cb5b14610dd157806391c4637114610d5e57806391ddadf414610d3357806395d89b4114610c7857806398cd615314610aea5780639ab24eb014610a89578063a9059cbb14610989578063beb96be514610964578063c3cda52014610820578063c7a2f1de146106f0578063cd6106f8146106c8578063cd63c4d21461066a578063d2482469146105b6578063d505accf14610429578063d699d7d214610400578063dd62ed3e146103cc578063f04e283e1461037f578063f2fde38b14610342578063f50096041461030a578063f68d90d8146102ed578063f77c4791146102c55763fee81cf41461028f575f80fd5b346102c15760203660031901126102c1576102a8612512565b63389a75e1600c525f52602080600c2054604051908152f35b5f80fd5b346102c1575f3660031901126102c1576005546040516001600160a01b039091168152602090f35b346102c1575f3660031901126102c1576020600454604051908152f35b346102c15760203660031901126102c1576001600160a01b0361032b612512565b165f52600a602052602060405f2054604051908152f35b60203660031901126102c157610356612512565b61035e61287e565b8060601b156103725761037090612da5565b005b637448fbae5f526004601cfd5b60203660031901126102c157610393612512565b61039b61287e565b63389a75e1600c52805f526020600c2090815442116103bf575f6103709255612da5565b636f5e88185f526004601cfd5b346102c15760403660031901126102c15760206103f86103ea612512565b6103f2612528565b90612841565b604051908152f35b346102c15760603660031901126102c15761037061041c612512565b6044359060243590612ab9565b346102c15760e03660031901126102c157610442612512565b61044a612528565b604435916064356084359260ff841684036102c1576001600160a01b0316936e22d473030f116ddee9f6b43ac78ba3851881191517156105a95761048c6125b4565b602081519101209082421161059c576040519360018060a01b03169465383775081901600e52855f5260c06020600c20958654955f805160206136278339815191528252602082019586528660408301965f8051602061350783398151915288528b6060850198468a528c608087019330855260a08820602e527f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9885252528688525260a082015220604e526042602c205f5260ff1660205260a43560405260c43560605260208060805f60015afa93853d510361058f575f8051602061360783398151915294602094019055856303faf4f960a51b176040526034602c2055a3005b63ddafbaef5f526004601cfd5b631a15a3cc5f526004601cfd5b633f68539a5f526004601cfd5b346102c15760203660031901126102c1576001600160a01b036105d7612512565b165f52600b60205260405f20604051806020835491828152019081935f5260205f20905f5b8181106106545750505081610612910382612591565b604051918291602083019060208452518091526040830191905f5b81811061063b575050500390f35b825184528594506020938401939092019160010161062d565b82548452602090930192600192830192016105fc565b346102c1575f3660031901126102c15763ff466c9f60601b5460209060301c65ffffffffffff168061069e57604051908152f35b600163ff466c9f60601b0301805460601c903082146106be575b506103f8565b90501954826106b8565b346102c1575f3660031901126102c157602065ffffffffffff60065460b01c16604051908152f35b346102c15760203660031901126102c1576004354360301c5f033d3d3e65ffffffffffff43168110156108135763ff466c9f60601b5460301c65ffffffffffff165f60068210156107ac575b81811061077957602082600163ff466c9f60601b03810190815460601c901515029030821461076f575b50604051908152f35b9050195482610766565b9080820160011c9065ffffffffffff63ff466c9f60601b830154168410156107a257509061073c565b915060010161073c565b9060108161ffff1060041b82811c60ff1060031b1760011c1b8082040160011c8082040160011c8082040160011c8082040160011c8082040160011c8082040160011c81039065ffffffffffff63ff466c9f60601b830154168410156107a257509061073c565b63f98744645f526004601cfd5b346102c15760c03660031901126102c157610839612512565b6044359060243560643560ff811681036102c1576108556125b4565b6020815191012084421161095757604051947fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf5f5260018060a01b0385166020528360405260605260805f206040526119015f525f80516020613627833981519152855260208501525f80516020613507833981519152604085015246606085015230608085015260a084206020526042601e205f5260ff1660205260843560405260a4356060526020600160805f825afa51926040525f6060523d15906338377508600c52835f526020600c2054181761094a57610370916338377508600c52805f526020600c2080546001019055612d40565b631838d95c5f526004601cfd5b633480e9e15f526004601cfd5b346102c15760403660031901126102c157610370610980612512565b60243590612b56565b346102c15760403660031901126102c1576109a2612512565b6024356109b081833361299a565b6387a211a2600c52335f526020600c2091825492838311610a7c5782610a2d94039055805f526020600c2082815401905581602052600c5160601c335f805160206135a7833981519152602080a33315610a5a575b6001600160a01b03811615610a38575b610a27610a2133612807565b91612807565b9061301d565b602060405160018152f35b4360301c5f033d3d3e610a538265ffffffffffff431661341c565b5050610a15565b4360301c5f033d3d3e610a758265ffffffffffff43166132eb565b5050610a05565b63f4d678b85f526004601cfd5b346102c15760203660031901126102c157610aa2612512565b63ff466c9f6004525f5260206017600c2065ffffffffffff815460301c169081610acf5750604051908152f35b015f1901805460601c90308203610766579050195482610766565b346102c15760203660031901126102c1576004356001600160401b0381116102c157610b1a903690600401612687565b610b2261287e565b80516001600160401b038111610c6457610b3d60025461253e565b601f8111610c14575b506020601f8211600114610ba0579181610b90925f805160206135e7833981519152945f91610b95575b508160011b915f199060031b1c1916176002555b604051918291826124e8565b0390a1005b905082015185610b70565b601f1982169060025f52805f20915f5b818110610bfc5750925f805160206135e7833981519152949260019282610b909610610be4575b5050811b01600255610b84565b8401515f1960f88460031b161c191690558580610bd7565b91926020600181928689015181550194019201610bb0565b60025f525f805160206134e7833981519152601f830160051c81019160208410610c5a575b601f0160051c01905b818110610c4f5750610b46565b5f8155600101610c42565b9091508190610c39565b634e487b7160e01b5f52604160045260245ffd5b346102c1575f3660031901126102c1576040515f600154610c988161253e565b8084529060018116908115610d0f5750600114610cc4575b610cc083610b8481850382612591565b0390f35b60015f9081525f805160206135c7833981519152939250905b808210610cf557509091508101602001610b84610cb0565b919260018160209254838588010152019101909291610cdd565b60ff191660208086019190915291151560051b84019091019150610b849050610cb0565b346102c1575f3660031901126102c1574360301c5f033d3d3e602060405165ffffffffffff43168152f35b346102c1575f3660031901126102c1576005546001600160a01b03163303610dc35760065460ff8160a81c1615610db45760ff60a81b19166006556040515f81525f8051602061356783398151915290602090a1005b630e549a7960e11b5f5260045ffd5b6282b42960e81b5f5260045ffd5b346102c1575f3660031901126102c157638b78c6d819546040516001600160a01b039091168152602090f35b346102c1575f3660031901126102c157610e1561287e565b60065460ff8160a01c1615610e305760ff60a01b1916600655005b634bc0a9fb60e01b5f5260045ffd5b346102c15760403660031901126102c157610e58612512565b6024359063ff466c9f6004525f526017600c2065ffffffffffff815460301c16821015610eb257604091018054908160601c90308214610ea8575b5082519165ffffffffffff1682526020820152f35b9050195483610e93565b6386df9d105f526004601cfd5b346102c1576101c03660031901126102c1576004356001600160401b0381116102c157610ef0903690600401612687565b6024356001600160401b0381116102c157610f0f903690600401612687565b6044359190606435906001600160a01b0382168083036102c1576084356001600160a01b03811691908290036102c15760a435916001600160401b0383116102c157366023840112156102c1578260040135610f6a816126dc565b93610f786040519586612591565b8185526024602086019260061b820101903682116102c157602401915b81831061192757505060c43590506001600160401b0381116102c157610fbf903690600401612707565b9360e4356001600160401b0381116102c157610fdf903690600401612775565b92610104356001600160401b0381116102c157611000903690600401612775565b92610124356001600160401b0381116102c157611021903690600401612687565b61016435906101443565ffffffffffff83168084036102c157610184356001600160a01b03811693908490036102c1576101a4356001600160401b0381116102c157611071903690600401612707565b9763409feecd199e8f805460038192556118fe575b5087638b78c6d81955875f5f805160206135878339815191528180a38051906001600160401b038211610c645781906110bf5f5461253e565b601f81116118a4575b50602090601f8311600114611841575f92611836575b50508160011b915f199060031b1c1916175f555b8051906001600160401b038211610c6457819061111060015461253e565b601f81116117db575b50602090601f8311600114611775575f9261176a575b50508160011b915f199060031b1c1916176001555b426003558051906001600160401b038211610c6457819061116660025461253e565b601f811161170f575b50602090601f83116001146116a9575f9261169e575b50508160011b915f199060031b1c1916176002555b8015801590611695575b611591575b505050505050508351918051831480611587575b15611578578351935f5b85811061145f575050670b1a2bc2ec5000008802888104670b1a2bc2ec500000148915171561144b575f95670de0b6b3a76400009091049486949392915b8486106112b15750505050505080821161129b5750838111611284579061123982849561123f946004558161127557612834565b90612e0b565b61124557005b6002905560016020527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2602080a1005b61127f8230612e0b565b612834565b83906305767d1760e01b5f5260045260245260445ffd5b906323f3f88b60e01b5f5260045260245260445ffd5b90919293949660018060a01b036112c889846127d2565b5116976112d581866127d2565b516112e082886127d2565b519980151580611442575b1561142f576112fc8287811061281a565b805f52600a60205260405f206113138c82546127e6565b9055805f52600a60205260405f20548a81116114185750805f52600960205260405f20825f5260205260405f2061134b8c82546127e6565b9055805f52600c60205260405f20600160ff198254161790558a61136f8383613297565b5c156113b8575b60206113a57f6b467f0a76daac5283d2251b6e7660fed01ea99dbd70aa7092f3318731690c9d926001976127e6565b9c604051908152a3019493929190611205565b5060016113c58383613297565b5d5f818152600b6020526040902080549094600160401b821015610c645760018201808755821015611404575f9586526020909520018290558a611376565b634e487b7160e01b5f52603260045260245ffd5b8a90630443fb3960e11b5f5260045260245260445ffd5b82630decee6760e31b5f5260045260245ffd5b508a15156112eb565b634e487b7160e01b5f52601160045260245ffd5b61146981836127d2565b516020810180519192916001600160401b0316801590811561156a575b81611555575b501561154257600854600160401b811015610c64578060016114b19201600855612655565b93909361152f575183549151600160401b600160801b03604082811b919091166001600160401b039384166001600160801b0319909516851717909555935160019484937fde48917a7c688e2f10cf41d45c1a7529ec84f5f9b9a08866ecf9453c417ad2c5938392611526929116908361266d565b0390a2016111c7565b634e487b7160e01b5f525f60045260245ffd5b506352fbb5df60e01b5f5260045260245ffd5b84516001600160401b0316111590508d61148c565b620151808110159150611486565b631dc0052360e11b5f5260045ffd5b50815183146111bd565b8115158061168c575b156116795742811115611663575060075560068054600580546001600160a01b031916909317909255600160a81b600160e01b031990911660b09290921b65ffffffffffff60b01b1691909117600160a81b1790555f908152600c6020526040808220805460ff199081166001908117909255938352908220805490931617909155815191905b82811061163157808080806111a9565b6001906001600160a01b0361164682856127d2565b51165f52600c60205260405f208260ff1982541617905501611621565b630ee945a760e31b5f526004524260245260445ffd5b50632a9f5c1f60e01b5f5260045260245ffd5b508d821061159a565b508115156111a4565b015190505f80611185565b60025f9081528281209350601f198516905b8181106116f757509084600195949392106116df575b505050811b0160025561119a565b01515f1960f88460031b161c191690555f80806116d1565b929360206001819287860151815501950193016116bb565b60025f529091505f805160206134e7833981519152601f840160051c81019160208510611760575b90601f859493920160051c01905b818110611752575061116f565b5f8155849350600101611745565b9091508190611737565b015190505f8061112f565b60015f9081528281209350601f198516905b8181106117c357509084600195949392106117ab575b505050811b01600155611144565b01515f1960f88460031b161c191690555f808061179d565b92936020600181928786015181550195019301611787565b60015f529091505f805160206135c7833981519152601f840160051c8101916020851061182c575b90601f859493920160051c01905b81811061181e5750611119565b5f8155849350600101611811565b9091508190611803565b015190505f806110de565b5f8080528281209350601f198516905b81811061188c5750908460019594939210611874575b505050811b015f556110f2565b01515f1960f88460031b161c191690555f8080611867565b92936020600181928786015181550195019301611851565b5f80529091505f80516020613527833981519152601f840160051c810191602085106118f4575b90601f859493920160051c01905b8181106118e657506110c8565b5f81558493506001016118d9565b90915081906118cb565b909f90600181811c14303b101561191a5760ff1b1b9e5f611086565b63f92ee8a95f526004601cfd5b6040833603126102c1576020604091825161194181612576565b61194a866126f3565b81526119578387016126f3565b83820152815201920191610f95565b346102c1575f3660031901126102c157602060ff60065460a01c166040519015158152f35b346102c15760203660031901126102c1576119a4612512565b6338377508600c525f52602080600c2054604051908152f35b346102c15760203660031901126102c1576119d6612512565b63ff466c9f6004525f52602065ffffffffffff6017600c205460301c16604051908152f35b5f3660031901126102c157611a0e61287e565b65ffffffffffff60065460b01c164210611a46575b5f638b78c6d819545f805160206135878339815191528280a35f638b78c6d81955005b5f8052600c6020525f805160206134c7833981519152805460ff19166001179055611a23565b346102c15760203660031901126102c157611a85612512565b6387a211a2600c525f52602080600c2054604051908152f35b346102c15760403660031901126102c1576001600160a01b03611abf612512565b165f52600960205260405f206024355f526020526040805f206001815491015482519182526020820152f35b346102c15760203660031901126102c1576004356008548110156102c157611b15610cc091612655565b505460408051928392909181901c6001600160401b0390811691168361266d565b346102c15760203660031901126102c157610370611b52612512565b33612d40565b346102c15760203660031901126102c1576020611b7b611b76612512565b612807565b6040516001600160a01b039091168152f35b5f3660031901126102c15763389a75e1600c52335f525f6020600c2055337ffa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c925f80a2005b346102c1575f3660031901126102c1576020600854604051908152f35b346102c15760203660031901126102c157611c07612512565b6001600160a01b0381165f908152600b6020908152604080832090518154808252918452828420909492850191845b818110611c925750505083611c4c910384612591565b8251905f935b828510611c6457602084604051908152f35b909192611c87600191611c81611c7a88866127d2565b518661289a565b906127e6565b940193929190611c52565b8254845260209093019260019283019201611c36565b346102c1575f3660031901126102c157610cc0604051611cc9604082612591565b601d81527f6d6f64653d626c6f636b6e756d6265722666726f6d3d64656661756c740000006020820152604051918291826124e8565b346102c15760203660031901126102c157600654600435906001600160a01b0381161580611eb4575b611ea55760ff8160a81c16611de2575b506387a211a2600c52335f526020600c2090815491828211610a7c578161037093039055806805345cdf77eb68f44c54036805345cdf77eb68f44c55805f525f335f805160206135a7833981519152602083a33315611dc0575b4360301c5f033d3d3e611dad8165ffffffffffff431661341c565b5050611db833612807565b610a276127f3565b4360301c5f033d3d3e611ddb8165ffffffffffff43166132eb565b5050611d92565b33151580611e9e575b80611e95575b15611d38575f8052600c6020525f805160206134c78339815191525460ff16611d385765ffffffffffff8160b01c1642105f14611e6c57506387a211a2600c525f8052611e43816020600c20546127e6565b60075490818111611e575750505b81611d38565b631c71225560e31b5f5260045260245260445ffd5b60ff60a81b1916600655604051600181525f8051602061356783398151915290602090a1611e51565b50301515611df1565b505f611deb565b632e13674560e01b5f5260045ffd5b5060ff8160a01c16611d28565b346102c1575f3660031901126102c1576040515f600254611ee18161253e565b8084529060018116908115610d0f5750600114611f0857610cc083610b8481850382612591565b60025f9081525f805160206134e7833981519152939250905b808210611f3957509091508101602001610b84610cb0565b919260018160209254838588010152019101909291611f21565b346102c15760403660031901126102c157611f6c612512565b602435904360301c5f033d3d3e65ffffffffffff43168210156108135763ff466c9f6004525f526017600c20905f9065ffffffffffff835460301c16916006831015612010575b905b828210611fe157602083855f199082010190815460601c901515029030821461076f5750604051908152f35b909180830160011c9065ffffffffffff85830154168310156120065750915b90611fb5565b9250600101612000565b9160108161ffff1060041b82811c60ff1060031b1760011c1b8082040160011c8082040160011c8082040160011c8082040160011c8082040160011c8082040160011c81039065ffffffffffff8583015416831015612070575091611fb3565b9250600101611fb3565b346102c15760203660031901126102c15761037060043533612b56565b346102c15760403660031901126102c15761037060243560043533612ab9565b346102c1575f3660031901126102c157602060a06120d36125b4565b828151910120604051905f805160206136278339815191528252838201525f80516020613507833981519152604082015246606082015230608082015220604051908152f35b346102c1575f3660031901126102c157602060405160128152f35b5f3660031901126102c15763389a75e1600c52335f526202a30042016020600c2055337fdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d5f80a2005b346102c1575f3660031901126102c1576020600354604051908152f35b346102c15760603660031901126102c1576121b3612512565b6121bb612528565b604435906121ca82828561299a565b8260601b6e22d473030f116ddee9f6b43ac78ba3330361229a575b6387a211a217600c526020600c208054808411610a7c57610a2d94610a279285610a2193039055835f526020600c2085815401905584602052600c5160601c60018060a01b03821690815f805160206135a7833981519152602080a315612278575b6001600160a01b038416612807575b4360301c5f033d3d3e6122718565ffffffffffff431661341c565b5050612807565b4360301c5f033d3d3e6122938565ffffffffffff43166132eb565b5050612247565b33602052637f5e9f208117600c526034600c209081549182196122c0575b5090506121e5565b8285116122d757846387a211a293039055856122b8565b6313be252b5f526004601cfd5b346102c15760403660031901126102c15760206103f8612302612512565b6024359061289a565b346102c15760203660031901126102c157612324612512565b61232c61287e565b6006549060ff8260a01c16612379576001600160a81b03199091166001600160a01b0391909116908117600160a01b176006555f908152600c60205260409020805460ff19166001179055005b635b3d9c4360e01b5f5260045ffd5b346102c1575f3660031901126102c15760206805345cdf77eb68f44c54604051908152f35b346102c1575f3660031901126102c157602060ff60065460a81c166040519015158152f35b346102c1575f3660031901126102c1576006546040516001600160a01b039091168152602090f35b346102c15760203660031901126102c1576001600160a01b0361241b612512565b165f52600c602052602060ff60405f2054166040519015158152f35b346102c15760403660031901126102c157612450612512565b602435906001600160a01b0381166e22d473030f116ddee9f6b43ac78ba31882191517156105a957602052637f5e9f20600c52335f52806034600c20555f52602c5160601c335f8051602061360783398151915260205fa3602060405160018152f35b346102c1575f3660031901126102c157610cc0610b846125b4565b346102c1575f3660031901126102c1576020906007548152f35b602060409281835280519182918282860152018484015e5f828201840152601f01601f1916010190565b600435906001600160a01b03821682036102c157565b602435906001600160a01b03821682036102c157565b90600182811c9216801561256c575b602083101461255857565b634e487b7160e01b5f52602260045260245ffd5b91607f169161254d565b604081019081106001600160401b03821117610c6457604052565b601f909101601f19168101906001600160401b03821190821017610c6457604052565b604051905f825f54916125c68361253e565b808352926001811690811561263657506001146125ec575b6125ea92500383612591565b565b505f80805290915f805160206135278339815191525b81831061261a5750509060206125ea928201016125de565b6020919350806001915483858901015201910190918492612602565b602092506125ea94915060ff191682840152151560051b8201016125de565b6008548110156114045760085f5260205f2001905f90565b6001600160401b0391821681529116602082015260400190565b81601f820112156102c1578035906001600160401b038211610c6457604051926126bb601f8401601f191660200185612591565b828452602083830101116102c157815f926020809301838601378301015290565b6001600160401b038111610c645760051b60200190565b35906001600160401b03821682036102c157565b9080601f830112156102c15781359061271f826126dc565b9261272d6040519485612591565b82845260208085019360051b8201019182116102c157602001915b8183106127555750505090565b82356001600160a01b03811681036102c157815260209283019201612748565b9080601f830112156102c157813561278c816126dc565b9261279a6040519485612591565b81845260208085019260051b8201019283116102c157602001905b8282106127c25750505090565b81358152602091820191016127b5565b80518210156114045760209160051b010190565b9190820180921161144b57565b63ff466c9f6004525f80526018600c205490565b63ff466c9f6004525f526018600c205490565b156128225750565b634ed2e7cf60e01b5f5260045260245ffd5b9190820391821161144b57565b906001600160a01b0381166e22d473030f116ddee9f6b43ac78ba31461287757602052637f5e9f20600c525f526034600c205490565b50505f1990565b638b78c6d81954330361288d57565b6382b429005f526004601cfd5b60018060a01b03165f52600960205260405f20815f5260205260405f20908154908115612993576128ca90612655565b50604051906128d882612576565b546001600160401b0380821680845260409290921c1660209092019182526003549061290490826127e6565b421061298b57815161291f906001600160401b0316826127e6565b4210612948575050600190915b0154808211156129425761293f91612834565b90565b50505f90565b6129529042612834565b8083029283040361144b57516001600160401b0316801561297757600191049161292c565b634e487b7160e01b5f52601260045260245ffd5b505050505f90565b5050505f90565b6006549291906001600160a01b0380831691908516821480612a8e575b611ea55760ff8560a81c166129ce575b5050505050565b6001600160a01b031681141580612a85575b80612a7b575b6129f1575b806129c7565b5f52600c60205260ff60405f20541615612a0c575b806129eb565b65ffffffffffff8360b01c1642105f14612a5057612a3a92506387a211a2600c525f526020600c20546127e6565b60075490818111611e575750505b5f8080612a06565b505060ff60a81b1916600655604051600181525f8051602061356783398151915290602090a1612a48565b50308114156129e6565b508015156129e0565b5060ff8560a01c166129b7565b15612aa4575050565b637ab3846b60e01b5f5260045260245260445ffd5b9091612ac983600854811061281a565b612ad3838361289a565b8015612b47575f80516020613547833981519152916020918115612b4057818181612aff931015612a9b565b612b378160018060a01b03861695865f526009855260405f20885f528552600160405f2001612b2f8382546127e6565b905530612f97565b604051908152a3565b9050612aff565b6311ec122f60e21b5f5260045ffd5b9060018060a01b03821691825f52600b60205260405f20916040519283602082549182815201915f5260205f20905f5b818110612d2a5750505083612b9c910384612591565b8251612ba7816126dc565b94612bb56040519687612591565b818652601f19612bc4836126dc565b013660208801375f925f5b838110612cb4575b508084612be692811015612a9b565b82948315612b47575f5b8484821015612ca457612c03828a6127d2565b51612c12575b50600101612bf0565b9480612c1e838b6127d2565b511115612c925780805b855f52600960205260405f20612c3e85876127d2565b515f52602052600160405f20018281540190550395612c5d83856127d2565b51855f805160206135478339815191526020604051868152a314612c81575f612c09565b50505050506125ea92505b30612f97565b612c9c828a6127d2565b518091612c28565b5050505050506125ea9250612c8c565b92919096959493612cef90612cd3612ccc86896127d2565b518761289a565b612cdd868a6127d2565b52612ce885896127d2565b51906127e6565b9287151580612d20575b612d0d576001019690919293949596612bcf565b50909150612be686939495969390612bd7565b5087841015612cf9565b8254845260209093019260019283019201612b86565b6125ea9160018060a01b0381169163ff466c9f600452805f526018600c2092808454945583600c5160601c7f3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f5f80a46387a211a2600c525f526020600c20549161301d565b65ffffffffffff60065460b01c164210612de4575b60018060a01b031680638b78c6d819545f805160206135878339815191525f80a3638b78c6d81955565b6001600160a01b0381165f908152600c60205260409020805460ff19166001179055612dba565b6006546001600160a01b03808316939291908116841480612f8a575b611ea55760ff8160a81c16612ee7575b506805345cdf77eb68f44c5492828401938410612eda576125ea936805345cdf77eb68f44c556387a211a2600c52815f526020600c2083815401905582602052600c5160601c5f5f805160206135a7833981519152602080a3824360301c5f0391823d3d3e65ffffffffffff431690612eb083836132eb565b505015612ec6575b505050610a27610a216127f3565b612ed2923d3d3e61341c565b50825f612eb8565b63e5cfe9575f526004601cfd5b83151580612f85575b80612f7b575b15612e3757835f52600c60205260ff60405f205416612e375765ffffffffffff8160b01c1642105f14612f5257506387a211a2600c52805f52612f3e826020600c20546127e6565b60075490818111611e575750505b5f612e37565b60ff60a81b1916600655604051600181525f8051602061356783398151915290602090a1612f4c565b5030841415612ef6565b612ef0565b5060ff8160a01c16612e27565b9190612fa482828561299a565b6387a211a28360601b17600c526020600c208054808411610a7c576125ea94610a279285610a2193039055835f526020600c2085815401905584602052600c5160601c60018060a01b03821690815f805160206135a7833981519152602080a315612278576001600160a01b0384161561225657612807565b91908115613292576001600160a01b0381811693908116908482146129c75781613187575b50508261304e57505050565b63ff466c9f6004525f526017600c20904360301c5f033d3d3e65ffffffffffff43165f9280549365ffffffffffff8560301c16923060601b91841561314c5750828401925f198401938454978860601c97308914613142575b880198888a10156130bf57639dbbeb755f526004601cfd5b65ffffffffffff1692848403613128575b505050818560301c9111176131265785938460a01c30861417156131115760301b1717815519555b5f526020525f8051602061364783398151915260405fa2565b929390915060601b9160301b171790556130f8565bfe5b600160301b909101905560019095019493505f80806130d0565b86195498506130a7565b94935090945082948360a01c30851417156131715717600160301b17815519556130f8565b50600160309392931b9160601b171790556130f8565b63ff466c9f6004525f526017600c204360301c5f033d3d3e65ffffffffffff43169080549065ffffffffffff8260301c16903060601b821561328557818301945f198601928354968760601c9630881461327b575b8b880398888a11156131f557635915f6865f526004601cfd5b65ffffffffffff1692848403613261575b505050818560301c9111176131265785938460a01c308614171561324c5760301b1717815519555b5f526020525f8051602061364783398151915260405fa25f80613042565b929390915060601b9160301b1717905561322e565b600160301b909101905560019095019493505f8080613206565b85195497506131dc565b635915f6865f526004601cfd5b505050565b906040519060208201927f587e449b7d81634c549a57a11acb36d05ac093a7ac55c177830838618db6429d845260018060a01b031660408301526060820152606081526132e5608082612591565b51902090565b90915f63ff466c9f60601b5465ffffffffffff8160301c16913060601b9083156133c85750600163ff466c9f60601b0383018054606081901c97909691939063ff466c9f60601b860190308a146133be575b8901978989101561335557639dbbeb755f526004601cfd5b65ffffffffffff16918383036133a0575b5050818560301c9111176131265785938460a01c308614171561338e5760301b171781551955565b929390915060601b9160301b17179055565b600160301b0163ff466c9f60601b5560019095019493505f80613366565b851954995061333d565b9592509390508115600117156132855781938260a01c30841417156134035717600160301b1763ff466c9f60601b5563ff466c9f60601b1955565b5060609190911b17600160301b1763ff466c9f60601b55565b90915f63ff466c9f60601b5465ffffffffffff8160301c16913060601b9083156134905750600163ff466c9f60601b0383018054606081901c97909691939063ff466c9f60601b860190308a14613486575b8903978989111561335557635915f6865f526004601cfd5b851954995061346e565b959250939050816132855781938260a01c30841417156134035717600160301b1763ff466c9f60601b5563ff466c9f60601b195556fe13649b2456f1b42fef0f0040b3aaeabcd21a76a0f3f5defd4f583839455116e8405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5acec89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563c5c52c2a9175470464d5ea4429889e7df2ea88630a3d32f4d0d3d2d448656210de7efbfa85e22db1ead49b6dfd1e807893247c3e22f7ded13eb9f9856a8076618be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf697b44a9429ef39a6d23e2de72846304d5b7873011084c4f1368f7a46545d51738c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a724","sourceMap":"4336:20209:5:-:0;;;;;;;-1:-1:-1;;6669:609:3;;;;;;2001:66;6669:609;-1:-1:-1;;;;;;6669:609:3;;;-1:-1:-1;4336:20209:5;;;;;;;6669:609:3;-1:-1:-1;;;;;;;6669:609:3;-1:-1:-1;;;;;6669:609:3;;;;;;;;;;;;-1:-1:-1;6669:609:3;;;;4336:20209:5;;;","linkReferences":{},"cborAuxdata":{},"transformations":null,"transformationValues":null},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"4336:20209:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;11885:237:0;;;4336:20209:5;11885:237:0;4336:20209:5;11885:237:0;;;;4336:20209:5;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;4899:25;4336:20209;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;:::i;:::-;;;;5726:63;4336:20209;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;8479:183;;;;;;8681:8;;;:::i;:::-;4336:20209:5;8479:183:0;;4336:20209:5;8479:183:0;4336:20209:5;8479:183:0;;4336:20209:5;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;10506:526;;;;4336:20209:5;10506:526:0;4336:20209:5;10506:526:0;;;;;;;;;4336:20209:5;11051:12:0;10506:526;;11051:12;:::i;10506:526::-;;4336:20209:5;10506:526:0;4336:20209:5;10506:526:0;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;:::i;:::-;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;15767:6;4336:20209;;:::i;:::-;;;;;;15767:6;;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;17958:337:1;;;;;;;;;;;;4336:20209:5;;:::i;:::-;;;;;;18495:24:1;18618:2753;;;;;;4336:20209:5;18618:2753:1;8363:339;;;;;;18618:2753;;;;;;4336:20209:5;18618:2753:1;4336:20209:5;;18618:2753:1;;;;;;-1:-1:-1;;;;;;;;;;;18618:2753:1;;4336:20209:5;18618:2753:1;;;;;;4336:20209:5;18618:2753:1;;;-1:-1:-1;;;;;;;;;;;18618:2753:1;;;4336:20209:5;18618:2753:1;;;;;;;4336:20209:5;18618:2753:1;;;;;;4336:20209:5;18618:2753:1;;;;;;;;;;;;;4336:20209:5;18618:2753:1;;;;;;;;;4336:20209:5;18618:2753:1;4336:20209:5;18618:2753:1;4336:20209:5;18618:2753:1;4336:20209:5;;;18618:2753:1;4336:20209:5;;;18618:2753:1;4336:20209:5;18618:2753:1;4336:20209:5;;;18618:2753:1;;;;;;;;;-1:-1:-1;;;;;;;;;;;18618:2753:1;4336:20209:5;18618:2753:1;;;;;;;;;4336:20209:5;18618:2753:1;;;;;;4336:20209:5;18618:2753:1;;4336:20209:5;18618:2753:1;4336:20209:5;18618:2753:1;;;;4336:20209:5;18618:2753:1;4336:20209:5;18618:2753:1;;17958:337;;4336:20209:5;17958:337:1;4336:20209:5;17958:337:1;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;:::i;:::-;;;;16916:14;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;18243:342:2;4336:20209:5;;18243:342:2;;;;;;;4336:20209:5;;;;;;18243:342:2;-1:-1:-1;;;;;18243:342:2;;;18883:1470;18243:342;;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5259:29;4336:20209;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5068:216:2;;;4336:20209:5;5068:216:2;;;;4336:20209:5;5068:216:2;4336:20209:5;10991:20:2;;;10987:54;;-1:-1:-1;;;18883:1470:2;5068:216;18883:1470;4336:20209:5;18883:1470:2;4336:20209:5;18883:1470:2;;;;;;;;;;;;4336:20209:5;18883:1470:2;8363:339:1;15179:154:2;18883:1470;;;;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;;18883:1470:2;;;;;;;;;;;;;;;4336:20209:5;;15179:154:2;4336:20209:5;;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;;15179:154:2;4336:20209:5;;18883:1470:2;;;;;;;;;;;;;10987:54;20520:116;4336:20209:5;20520:116:2;4336:20209:5;20520:116:2;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;7209:24:2;7332:1413;;;;;4336:20209:5;7332:1413:2;;;4336:20209:5;7332:1413:2;8363:339:1;;;;;7332:1413:2;;4336:20209:5;7332:1413:2;;4336:20209:5;7332:1413:2;4336:20209:5;7332:1413:2;4336:20209:5;;7332:1413:2;4336:20209:5;7332:1413:2;;4336:20209:5;7332:1413:2;-1:-1:-1;;;;;;;;;;;7332:1413:2;;4336:20209:5;7332:1413:2;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;7332:1413:2;;;;4336:20209:5;7332:1413:2;;;;4336:20209:5;7332:1413:2;;;4336:20209:5;7332:1413:2;;4336:20209:5;7332:1413:2;;;;4336:20209:5;7332:1413:2;4336:20209:5;7332:1413:2;4336:20209:5;7332:1413:2;4336:20209:5;;;7332:1413:2;4336:20209:5;;;7332:1413:2;4336:20209:5;;;;7332:1413:2;;;;;4336:20209:5;7332:1413:2;4336:20209:5;;7332:1413:2;;;17266:205:1;;;;;4336:20209:5;17266:205:1;4336:20209:5;17266:205:1;;;8759:22:2;8758:33;8754:255;;9069:9;16797:203:1;17266:205;;16797:203;;4336:20209:5;16797:203:1;4336:20209:5;17266:205:1;16797:203;;;4336:20209:5;16797:203:1;;;9069:9:2;:::i;8754:255::-;8859:140;4336:20209:5;8859:140:2;4336:20209:5;8859:140:2;;7332:1413;;4336:20209:5;7332:1413:2;4336:20209:5;7332:1413:2;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;16212:6;4336:20209;;:::i;:::-;;;16212:6;;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;9514:6:1;9498:10;;;9514:6;:::i;:::-;9574:1143;;;9498:10;4336:20209:5;9574:1143:1;4336:20209:5;9574:1143:1;;;;;;;;;;;;12442:6:2;9574:1143:1;;;;;4336:20209:5;9574:1143:1;4336:20209:5;9574:1143:1;;;;;;;;;4336:20209:5;9574:1143:1;;;;;9498:10;-1:-1:-1;;;;;;;;;;;4336:20209:5;9574:1143:1;;9498:10;12122:18:2;12118:128;;4336:20209:5;-1:-1:-1;;;;;4336:20209:5;;12259:16:2;12255:127;;4336:20209:5;12427:13:2;12410:15;9498:10:1;12410:15:2;:::i;:::-;12427:13;;:::i;:::-;12442:6;;:::i;:::-;4336:20209:5;;;;;;;12255:127:2;5068:216;;;4336:20209:5;5068:216:2;;;;12291:80;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12291:80:2;:::i;:::-;12255:127;;;;12118:128;5068:216;;;4336:20209:5;5068:216:2;;;;12156:79;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12156:79:2;:::i;:::-;12118:128;;;;9574:1143:1;;4336:20209:5;9574:1143:1;4336:20209:5;9574:1143:1;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;;;18243:342;;;;;;;;;;4336:20209:5;;;;;;;18243:342:2;;-1:-1:-1;;18243:342:2;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;4336:20209:5;;-1:-1:-1;;;;;4336:20209:5;;;;;14222:20;4336:20209;;:::i;:::-;;;;;;;;;;;;;;;;;;14257:25;4336:20209;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;;;;;;18883:1470:2;;;4336:20209:5;;;;;;;14222:20;4336:20209;;;;14257:25;;;;;:::i;:::-;;;;4336:20209;;;;;;;;;;;;;;;;14222:20;4336:20209;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;14257:25;4336:20209;;;;;;;;;;14222:20;4336:20209;;;;;;;18883:1470:2;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14222:20;4336:20209;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;22793:7;4336:20209;;;;:::i;:::-;;;;;22793:7;4336:20209;;;22793:7;;;;4336:20209;;;;;;;;;;;;;;:::i;:::-;;;;;22793:7;4336:20209;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;;;;22793:7;4336:20209;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;;-1:-1:-1;;4336:20209:5;;;;5068:216:2;;;4336:20209:5;5068:216:2;;;;4336:20209:5;;;;5068:216:2;4336:20209:5;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;6136:10;4336:20209;-1:-1:-1;;;;;4336:20209:5;6122:10;:24;4336:20209;;13115:20;4336:20209;;;;;;;;;-1:-1:-1;;;;4336:20209:5;13115:20;4336:20209;;;;;;-1:-1:-1;;;;;;;;;;;13214:27:5;4336:20209;;13214:27;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;11523:61:0;4336:20209:5;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;12478:70:0;;:::i;:::-;12487:12:5;4336:20209;;;;;;;;;-1:-1:-1;;;;4336:20209:5;12487:12;4336:20209;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;;;;10069:510;;;;;;;;;;;4336:20209:5;10069:510:2;;;;;;;;;;;;;;4336:20209:5;;;;10069:510:2;;;4336:20209:5;;;;;;;10069:510:2;;;;;;;;;;4336:20209:5;10069:510:2;4336:20209:5;10069:510:2;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;-1:-1:-1;;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;2001:66:3;;;3207:622;;;;;;;;;;4336:20209:5;6813:405:0;;;;5710:347;;4336:20209:5;-1:-1:-1;;;;;;;;;;;5710:347:0;;;4336:20209:5;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;;4336:20209:5;3207:622:3;4336:20209:5;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;;4336:20209:5;3207:622:3;4336:20209:5;;;;;;;;7998:15;3207:622:3;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;8023:20;4336:20209;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;;4336:20209:5;3207:622:3;4336:20209:5;;;;;8023:20;4336:20209;;8058:20;;;;:44;;;4336:20209;8054:810;;4336:20209;;;;;;;;;;;;;8984:38;;:76;;;4336:20209;;;;;;9193:9;4336:20209;9204:19;;;;;;2387:9;;;;;;;;;;;;;;;;4336:20209;;146:4:6;;;;;4336:20209:5;;146:4:6;;;9950:20:5;;;;;;11312:31;;;;;;;;;2524:9;;11418:29;;;;2524:9;;4336:20209;11685:28;4336:20209;;;11685:28;4336:20209;;;11582:16;11578:81;;11685:28;:::i;:::-;;;:::i;:::-;3892:296:3;;4336:20209:5;3892:296:3;8023:20:5;3892:296:3;;4336:20209:5;;3892:296:3;;4336:20209:5;3892:296:3;;4336:20209:5;11578:81;11635:12;11628:4;;11635:12;:::i;:::-;11685:28;:::i;2524:9::-;;;;;;4336:20209;2524:9;4336:20209;;;;;;2524:9;;;;;;4336:20209;2524:9;4336:20209;;;;;;2524:9;9972:3;8363:339:1;;;;;;;;;;;10013:16:5;;;;:::i;:::-;4336:20209;;10064:14;;;;;:::i;:::-;4336:20209;10109:10;;;;:::i;:::-;4336:20209;10177:25;;;;:39;;;9972:3;2524:9;;;10253:68;10261:28;;;;10253:68;:::i;:::-;4336:20209;;;10399:16;4336:20209;;;;;10399:39;4336:20209;;;10399:39;:::i;:::-;4336:20209;;;;;10399:16;4336:20209;;;;;;10545:38;;;2524:9;;4336:20209;;;;10762:9;4336:20209;;;;;;;;;;;;;10762:56;4336:20209;;;10762:56;:::i;:::-;4336:20209;;;;;10832:26;4336:20209;;;;;;;;;;;;;;19359:47;;;;;:::i;:::-;17646:58:4;10952:47:5;10948:194;;9972:3;4336:20209;11156:22;11197:49;11156:22;4336:20209;11156:22;;:::i;:::-;4336:20209;;;;;;11197:49;4336:20209;9939:9;;;;;;;10948:194;19548:47;4336:20209;19548:47;;;;:::i;:::-;18084:72:4;4336:20209:5;;;;11083:14;4336:20209;;;;;2524:9;;4336:20209;;-1:-1:-1;;;2524:9:5;;;;;4336:20209;2524:9;;;;;4336:20209;;;;;;;;;;;;;;;;;;10948:194;;4336:20209;;;;;;;;;;;;2524:9;;;;;;4336:20209;2524:9;4336:20209;;;;;;2524:9;;;;;;4336:20209;2524:9;4336:20209;;;;2524:9;10177:39;10206:10;;;;10177:39;;2387:9;4336:20209;;;;;;;;;;;9225:3;9271:12;;;;:::i;:::-;;4336:20209;9440:10;;4336:20209;;9271:12;;9440:10;-1:-1:-1;;;;;4336:20209:5;9440:15;;;:53;;;;9225:3;9439:80;;;9225:3;2653:6;;;;9567:16;2653:6;-1:-1:-1;;;2653:6:5;;;;;;4336:20209;2653:6;;;9567:16;2653:6;;:::i;:::-;;;;;;4336:20209;2653:6;;4336:20209;;-1:-1:-1;;;;;;;4336:20209:5;2653:6;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;-1:-1:-1;;;;;;2653:6:5;;;;;;;;;4336:20209;;-1:-1:-1;;4336:20209:5;;9610:46;;4336:20209;;9610:46;;4336:20209;;;;9610:46;:::i;:::-;;;;4336:20209;9193:9;;2653:6;4336:20209;;;;;;;;;;;2653:6;;;;;4336:20209;2653:6;4336:20209;;;;2653:6;9439:80;4336:20209;;-1:-1:-1;;;;;4336:20209:5;9498:21;;;-1:-1:-1;9439:80:5;;;9440:53;2653:6;9459:34;;;;-1:-1:-1;9440:53:5;;4336:20209;;;;;;;;;8984:76;4336:20209;;;9026:34;;8984:76;;8054:810;8126:20;;;:56;;;8054:810;4336:20209;;;7998:15;8244:34;;4336:20209;;;-1:-1:-1;8359:34:5;4336:20209;;;;8455:24;4336:20209;;-1:-1:-1;;;;;;4336:20209:5;;;;;;;-1:-1:-1;;;;;;;;4336:20209:5;;;;;;;;-1:-1:-1;;;4336:20209:5;;;;;-1:-1:-1;;;4336:20209:5;;;-1:-1:-1;4336:20209:5;;;8534:26;4336:20209;;;;;;;;-1:-1:-1;;4336:20209:5;;;8363:339:1;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;8734:18;;;;;;8054:810;;;;;;8754:3;4336:20209;;-1:-1:-1;;;;;8804:27:5;8363:339:1;8804:27:5;;:::i;:::-;4336:20209;;;;8534:26;4336:20209;;;;;;;;;;;;;;;8723:9;;4336:20209;;;;;;;;7998:15;4336:20209;;;;;;;;;;;;;;;;;8126:56;8150:32;;;;8126:56;;8058:44;8082:20;;;;8058:44;;4336:20209;;;;-1:-1:-1;4336:20209:5;;;;;8023:20;4336:20209;;;;;;;;-1:-1:-1;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;8023:20;4336:20209;;;;;;18883:1470:2;;4336:20209:5;;3207:622:3;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8023:20;4336:20209;;;;-1:-1:-1;;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;-1:-1:-1;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;4336:20209:5;;3207:622:3;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;-1:-1:-1;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;4336:20209:5;;3207:622:3;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;;;3207:622:3;;;;4336:20209:5;3207:622:3;;;;;;;;;;;;;;;;;;;4336:20209:5;3207:622:3;4336:20209:5;3207:622:3;;4336:20209:5;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5073:24;4336:20209;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;17266:205:1;;;4336:20209:5;17266:205:1;4336:20209:5;17266:205:1;;;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;9629:76:2;15179:154;;;9629:76;;;;4336:20209:5;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;12478:70:0;;:::i;:::-;4336:20209:5;24423:15;4336:20209;;;;24441:15;-1:-1:-1;24419:82:5;;4336:20209;;6813:405:0;;;-1:-1:-1;;;;;;;;;;;6813:405:0;;;4336:20209:5;-1:-1:-1;;6813:405:0;4336:20209:5;24419:82;4336:20209;;;24458:26;4336:20209;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;-1:-1:-1;;4336:20209:5;24497:4;4336:20209;;;24419:82;;4336:20209;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;7300:148:1;;;4336:20209:5;7300:148:1;4336:20209:5;7300:148:1;;;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;:::i;:::-;;;;5551:91;4336:20209;;;;;;;;;;;;;;;;;;5551:91;;4336:20209;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5434:41;4336:20209;5434:41;;;;;;4336:20209;5434:41;;:::i;:::-;-1:-1:-1;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;4336:20209:5;;;;6720:9:2;4336:20209:5;;:::i;:::-;6708:10:2;6720:9;:::i;4336:20209:5:-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;9831:339:0;;;;4336:20209:5;9831:339:0;4336:20209:5;9831:339:0;;;;;;4336:20209:5;9831:339:0;;4336:20209:5;;;;;;;-1:-1:-1;;4336:20209:5;;;;;16610:16;4336:20209;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;-1:-1:-1;;;;;4336:20209:5;;;;;;17710:14;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;17789:9;4336:20209;17784:98;17800:10;;;;;;4336:20209;;;;;;;;17812:3;17864:6;;;17831:40;4336:20209;17864:6;17840:31;17864:6;;;;:::i;:::-;4336:20209;17840:31;;:::i;:::-;17831:40;;:::i;:::-;17812:3;4336:20209;17789:9;;;;;;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;4336:20209:5;;;;22948:4;4336:20209;;;;-1:-1:-1;;;;;4336:20209:5;;22942:10;;:26;;4336:20209;22938:51;;4336:20209;;;;;22999:786;;4336:20209;24348:887:1;;;;13699:10:5;4336:20209;24348:887:1;4336:20209:5;24348:887:1;;;;;;;;;;;;12442:6:2;24348:887:1;;;;;;;;;;;4336:20209:5;24348:887:1;4336:20209:5;13699:10;-1:-1:-1;;;;;;;;;;;4336:20209:5;24348:887:1;;13699:10:5;12122:18:2;12118:128;;4336:20209:5;5068:216:2;;;4336:20209:5;5068:216:2;;;;12291:80;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12291:80:2;:::i;:::-;13699:10:5;;12410:15:2;13699:10:5;12410:15:2;:::i;:::-;12427:13;;:::i;12118:128::-;5068:216;;;4336:20209:5;5068:216:2;;;;12156:79;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12156:79:2;:::i;:::-;12118:128;;;;22999:786:5;13699:10;23136;;:30;;;22999:786;23136:53;;;22999:786;23132:643;22999:786;23132:643;4336:20209;;;23214:26;4336:20209;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;22999:786;23209:552;4336:20209;;;;;23272:15;:33;23268:475;4336:20209;;;7300:148:1;;23214:26:5;7300:148:1;4336:20209:5;7300:148:1;;23354:21:5;7300:148:1;4336:20209:5;23214:26;7300:148:1;;23354:21:5;:::i;:::-;23423:15;4336:20209;23409:29;;;;4336:20209;;23268:475;;;23209:552;22999:786;;4336:20209;;;;;;;;;;;;;23268:475;-1:-1:-1;;;;4336:20209:5;22948:4;4336:20209;;;;;;-1:-1:-1;;;;;;;;;;;23694:26:5;4336:20209;;23694:26;23268:475;;23136:53;23184:4;;23170:19;;23136:53;;:30;;4336:20209;23136:30;;22938:51;22977:12;;;4336:20209;22977:12;4336:20209;;22977:12;22942:26;4336:20209;;;;;;22942:26;;4336:20209;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;4581:22;4336:20209;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4581:22;4336:20209;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;5068:216:2;;;;4336:20209:5;5068:216:2;;;;4336:20209:5;5068:216:2;4336:20209:5;6039:20:2;;;6035:54;;15179:154;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;;;;6106:74;4336:20209:5;18883:1470:2;4336:20209:5;18883:1470:2;;5068:216;18883:1470;;;;;;;;;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;;18883:1470:2;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;15240:6;4336:20209;;15228:10;15240:6;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;14923:6;4336:20209;;;;14899:10;14923:6;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;21845:344:1;4336:20209:5;;:::i;:::-;;;;;;21722:24:1;4336:20209:5;21845:344:1;;-1:-1:-1;;;;;;;;;;;21845:344:1;;;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;21845:344:1;;;;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;6553:2:1;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;9239:383:0;;;;4336:20209:5;9239:383:0;7972:9;9132:15;4336:20209:5;9239:383:0;;;;;;4336:20209:5;9239:383:0;;4336:20209:5;;;;;;;-1:-1:-1;;4336:20209:5;;;;;4674:27;4336:20209;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;:::i;:::-;;;11300:6:1;;;;;;:::i;:::-;11485:2201;4336:20209:5;11485:2201:1;;;;;;4336:20209:5;11485:2201:1;;;;4336:20209:5;11485:2201:1;;;;;;;;;12442:6:2;11485:2201:1;12427:13:2;11485:2201:1;;12410:15:2;11485:2201:1;;;;;4336:20209:5;11485:2201:1;4336:20209:5;11485:2201:1;;;;;;;;;4336:20209:5;11485:2201:1;;;4336:20209:5;11485:2201:1;8363:339;;;;;11485:2201;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;11485:2201:1;;12122:18:2;12118:128;;4336:20209:5;-1:-1:-1;;;;;4336:20209:5;;12410:15:2;12255:127;;5068:216;;;4336:20209:5;5068:216:2;;;;12291:80;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12291:80:2;:::i;:::-;12255:127;;12410:15;:::i;12118:128::-;5068:216;;;4336:20209:5;5068:216:2;;;;12156:79;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12156:79:2;:::i;:::-;12118:128;;;;11485:2201:1;;4336:20209:5;11485:2201:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;11485:2201:1;4336:20209:5;11485:2201:1;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;17320:35;4336:20209;;:::i;:::-;;;17320:35;;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;12216:12:5;4336:20209;;;;;;;;;-1:-1:-1;;;;;;4336:20209:5;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;-1:-1:-1;;;4336:20209:5;12216:12;4336:20209;;;;;12311:26;4336:20209;;;;;;;-1:-1:-1;;4336:20209:5;8363:339:1;4336:20209:5;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;7028:68:1;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5163:32;4336:20209;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;4977:19;4336:20209;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;:::i;:::-;;;;5996:75;4336:20209;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;8363:339:1;;;;;;;;;;;4336:20209:5;8764:413:1;;;;;4336:20209:5;8764:413:1;;;;;;4336:20209:5;8764:413:1;;;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;8764:413:1;4336:20209:5;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5333:30;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;:::o;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;:::o;:::-;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;:::o;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:::o;:::-;-1:-1:-1;4336:20209:5;;;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5434:41;4336:20209;;;;;;5434:41;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;-1:-1:-1;4336:20209:5;:::o;:::-;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;:::o;:::-;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;4336:20209:5;;;;;;:::o;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;6258:305:2:-;6394:163;;;4336:20209:5;6394:163:2;;;;;;6258:305;:::o;:::-;6394:163;;;;;;;;;6258:305;:::o;2524:9:5:-;;;;;:::o;:::-;;;;;;;4336:20209;;2524:9;;;;;;;;;;;;:::o;7549:495:1:-;;-1:-1:-1;;;;;4336:20209:5;;5869:42:1;7746:19;7742:49;;7854:184;;;;;4336:20209:5;7854:184:1;;;;;7549:495;:::o;7742:49::-;18883:1470:2;;;;7767:24:1;:::o;7292:355:0:-;-1:-1:-1;;7390:251:0;;;;;7292:355::o;7390:251::-;;;;;;;18373:826:5;8363:339:1;;;;;4336:20209:5;-1:-1:-1;4336:20209:5;18501:9;4336:20209;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;-1:-1:-1;4336:20209:5;;;;18595:16;;;18591:30;;18659:28;;;:::i;:::-;4336:20209;;;;;;;:::i;:::-;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;18750:12;4336:20209;;18837:15;;4336:20209;18837:15;:::i;:::-;18709;18833:19;18829:33;;4336:20209;;18943:18;;-1:-1:-1;;;;;4336:20209:5;18943:18;;:::i;:::-;18709:15;18938:23;8363:339:1;;18977:20:5;;19117:17;18977:20;18934:154;;19117:17;4336:20209;19151:17;;;;;;19171;;;:::i;:::-;18373:826;:::o;19151:41::-;;;-1:-1:-1;18373:826:5;:::o;18934:154::-;19053:9;18709:15;;19053:9;:::i;:::-;2387;;;;;;;;;4336:20209;-1:-1:-1;;;;;4336:20209:5;146:4:6;;;;19117:17:5;146:4:6;;18934:154:5;;;146:4:6;4336:20209:5;;;-1:-1:-1;146:4:6;;;;;-1:-1:-1;146:4:6;18829:33:5;18854:8;;;;-1:-1:-1;18854:8:5;:::o;18591:30::-;18613:8;;;-1:-1:-1;18613:8:5;:::o;22839:952::-;22948:4;4336:20209;;22839:952;;-1:-1:-1;;;;;4336:20209:5;;;;22839:952;4336:20209;;22942:10;;;:26;;22839:952;22938:51;;4336:20209;;;;;22999:786;;22839:952;;;;;;:::o;22999:786::-;-1:-1:-1;;;;;4336:20209:5;23136:10;;;;:30;;22999:786;23136:53;;;22999:786;23132:643;;22999:786;;;;23132:643;-1:-1:-1;4336:20209:5;23214:26;4336:20209;;;;-1:-1:-1;4336:20209:5;;;23213:31;23209:552;;23132:643;;;;23209:552;4336:20209;;;;;23272:15;:33;23268:475;4336:20209;;;23354:21;7300:148:1;;;23214:26:5;7300:148:1;-1:-1:-1;7300:148:1;4336:20209:5;23214:26;7300:148:1;;23354:21:5;:::i;:::-;23423:15;4336:20209;23409:29;;;;4336:20209;;23268:475;;;23209:552;;;;;23268:475;-1:-1:-1;;;;;;4336:20209:5;22948:4;4336:20209;;;;;;-1:-1:-1;;;;;;;;;;;23694:26:5;4336:20209;;23694:26;23268:475;;23136:53;23184:4;;23170:19;;;23136:53;;:30;23150:16;;;;23136:30;;22942:26;4336:20209;;;;;;22942:26;;4336:20209;;;;;;:::o;:::-;;;;;;;;;;;;;20045:623;;;20142:76;4336:20209;20163:16;4336:20209;20150:36;;20142:76;:::i;:::-;20249:35;;;;:::i;:::-;20302:13;;4336:20209;;-1:-1:-1;;;;;;;;;;;20614:47:5;4336:20209;;20352:10;;;;20372:19;;;20364:77;20372:19;;;20364:77;:::i;:::-;20592:6;8363:339:1;;;;;;4336:20209:5;;;;-1:-1:-1;4336:20209:5;20485:9;4336:20209;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;20485:49;4336:20209;-1:-1:-1;4336:20209:5;20485:49;:59;4336:20209;;;20485:59;:::i;:::-;4336:20209;;20572:4;20592:6;:::i;:::-;4336:20209;;;;;20614:47;20045:623::o;20348:126::-;20456:18;;20348:126;;4336:20209;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;20858:1454;;8363:339:1;;;;;4336:20209:5;;;;-1:-1:-1;4336:20209:5;20961:14;4336:20209;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;;4336:20209:5;;;:::i;:::-;;;;;;;-1:-1:-1;21217:9:5;-1:-1:-1;21228:10:5;;;;;;21212:253;21533:15;;;21525:69;21533:15;;;;21525:69;:::i;:::-;21604:14;21686:10;;;4336:20209;;-1:-1:-1;21811:3:5;21799:10;;;;;;;21834;;;;:::i;:::-;4336:20209;21830:383;;21811:3;;4336:20209;;21788:9;;21830:383;21887:10;;;;;;:::i;:::-;4336:20209;21887:18;:39;;;;;;4336:20209;-1:-1:-1;4336:20209:5;21976:9;4336:20209;;;-1:-1:-1;4336:20209:5;21999:6;;;;:::i;:::-;4336:20209;-1:-1:-1;4336:20209:5;;;;;-1:-1:-1;4336:20209:5;21976:45;4336:20209;;;;;;;22142:6;;;;;:::i;:::-;4336:20209;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;;22114:45;22181:10;22177:21;;21830:383;;;22177:21;22193:5;;;;;22298:6;22193:5;;21783:440;22278:4;22298:6;:::i;21887:39::-;21916:10;;;;:::i;:::-;4336:20209;21887:39;;;;21799:10;;;;;;;22298:6;21799:10;;;;21240:3;21296:6;;;;;;;21317:19;21296:6;21272:31;21296:6;;;;:::i;:::-;4336:20209;21272:31;;:::i;:::-;21259:44;;;;:::i;:::-;4336:20209;21326:10;;;;:::i;:::-;4336:20209;21317:19;;:::i;:::-;21354:10;;;;:29;;;21240:3;21350:105;;4336:20209;;21217:9;;;;;;;;;;21350:105;21403:14;;;;21525:69;21403:14;;;;;21435:5;;;;21354:29;21368:15;;;;;21354:29;;4336:20209;;;;;;;;;;;;;;;;;;14022:660:2;14650:24;14022:660;8363:339:1;;;;;14169:436:2;;;;;;;-1:-1:-1;14169:436:2;;;;;;;;;;;;;;;;-1:-1:-1;14169:436:2;;7300:148:1;14169:436:2;7300:148:1;-1:-1:-1;7300:148:1;;14169:436:2;7300:148:1;;14650:24:2;;:::i;24169:374:5:-;4336:20209;24423:15;4336:20209;;;;24441:15;-1:-1:-1;24419:82:5;;24169:374;8363:339:1;;;;;6813:405:0;;;;;-1:-1:-1;;;;;;;;;;;;6813:405:0;;-1:-1:-1;;6813:405:0;24169:374:5:o;24419:82::-;-1:-1:-1;;;;;4336:20209:5;;-1:-1:-1;4336:20209:5;;;24458:26;4336:20209;;;;;;;-1:-1:-1;;4336:20209:5;8363:339:1;4336:20209:5;;;24419:82;;22599:1172:1;22948:4:5;4336:20209;-1:-1:-1;;;;;4336:20209:5;;;;22599:1172:1;;4336:20209:5;;;22942:10;;;:26;;22599:1172:1;22938:51:5;;4336:20209;;;;;22999:786;;22599:1172:1;22766:946;;;;;;;;;;;;12442:6:2;22766:946:1;;;;;;;22698:1;22766:946;;;;;;;;;;;;;;;;;22698:1;-1:-1:-1;;;;;;;;;;;22766:946:1;;;5068:216:2;;;;22698:1:1;5068:216:2;;;;;;4336:20209:5;5068:216:2;4336:20209:5;12156:79:2;;;;;:::i;:::-;12259:16;;;12255:127;;22599:1172:1;12410:15:2;;;12427:13;12410:15;;:::i;12255:127::-;12291:80;5068:216;;;;12291:80;:::i;:::-;12255:127;;;;;22766:946:1;;22698:1;22766:946;;;;22999:786:5;23136:10;;;:30;;;22999:786;23136:53;;;22999:786;23132:643;22999:786;23132:643;4336:20209;22698:1:1;4336:20209:5;23214:26;4336:20209;;;;22698:1:1;4336:20209:5;;;22999:786;23209:552;4336:20209;;;;;23272:15;:33;23268:475;4336:20209;;;7300:148:1;;23214:26:5;7300:148:1;;22698:1;7300:148;23354:21:5;7300:148:1;4336:20209:5;23214:26;7300:148:1;;23354:21:5;:::i;:::-;23423:15;4336:20209;23409:29;;;;4336:20209;;23268:475;;;23209:552;22999:786;;23268:475;-1:-1:-1;;;;4336:20209:5;22948:4;4336:20209;;;;;;-1:-1:-1;;;;;;;;;;;23694:26:5;4336:20209;;23694:26;23268:475;;23136:53;23184:4;;23170:19;;;23136:53;;:30;;;22942:26;4336:20209;;;;;;22942:26;;25644:1396:1;;;25763:6;;;;;:::i;:::-;25823:1164;;;;;;;;;;;;;;;;;12442:6:2;25823:1164:1;12427:13:2;25823:1164:1;;12410:15:2;25823:1164:1;;;;;;;;;;;;;;;;;;;;;;;8363:339;;;;;25823:1164;;;;-1:-1:-1;;;;;;;;;;;25823:1164:1;;;12122:18:2;12118:128;;-1:-1:-1;;;;;4336:20209:5;;12259:16:2;12255:127;;12410:15;:::i;12614:1260::-;;;12715:20;;12711:33;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;12856:24:2;;;12852:37;;12902:16;12898:484;;12614:1260;13395:14;;;13391:477;;12614:1260;;;:::o;13391:477::-;15179:154;;;12733:1;15179:154;;;;5068:216;;;;12733:1;5068:216;;;;4336:20209:5;5068:216:2;4336:20209:5;12733:1:2;15520:16;15595:2440;;;4336:20209:5;15595:2440:2;5068:216;15595:2440;;;;;;;;;;;;;;;18883:1470;;;15595:2440;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15595:2440:2;15179:154;15595:2440;;;4336:20209:5;15595:2440:2;;;;;;;;;;;;;5068:216;15595:2440;;;;;;;;;;;;;;;;;;5068:216;15595:2440;;;;;;;;12733:1;13613:245;;;-1:-1:-1;;;;;;;;;;;13613:245:2;12733:1;13613:245;12614:1260::o;15595:2440::-;;;;;;;;;5068:216;15595:2440;;;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;13547:4;15595:2440;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;;;;;8363:339:1;15595:2440:2;;;;;;;;;;;;;;12898:484;15179:154;;;12733:1;15179:154;;;;5068:216;;;12733:1;5068:216;;;;4336:20209:5;5068:216:2;4336:20209:5;12989:75:2;15595:2440;;;4336:20209:5;15595:2440:2;5068:216;15595:2440;;;;;;;;;;;;;18883:1470;;;15595:2440;;;;;;;;;;;;;;;;;;;;;;;;;;;12733:1;15595:2440;15179:154;15595:2440;;;4336:20209:5;15595:2440:2;;;;;;;;;;;;;5068:216;15595:2440;;;;;;;;;;;;;;;;;;5068:216;15595:2440;;;;;;;;12733:1;13125:247;;;-1:-1:-1;;;;;;;;;;;13125:247:2;12733:1;13125:247;12898:484;;;;15595:2440;;;;;;;;;5068:216;15595:2440;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;-1:-1:-1;15595:2440:2;;;;12733:1;15595:2440;15179:154;15595:2440;;12711:33;12737:7;;;:::o;19616:204:5:-;;4336:20209;;19748:64;;;;4336:20209;2785:57;4336:20209;;8363:339:1;;;;;4336:20209:5;;2785:57;;4336:20209;2785:57;;;4336:20209;2785:57;19748:64;;;;;;:::i;:::-;4336:20209;19738:75;;19616:204;:::o;15379:2662:2:-;;;4336:20209:5;15179:154:2;4336:20209:5;;15595:2440:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15595:2440:2;;;;4336:20209:5;15595:2440:2;;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;;;;;;;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15379:2662::o;15595:2440::-;;;;;;;;;;;;;;;15379:2662::o;15595:2440::-;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;15595:2440:2;12230:4;15595:2440;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;;12230:4;15595:2440;;;;;;;;;;;;;;;;;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;;15595:2440:2;15379:2662::o;15595:2440::-;-1:-1:-1;15595:2440:2;;;;;;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;15595:2440:2;15379:2662::o;:::-;;;4336:20209:5;15179:154:2;4336:20209:5;;15595:2440:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15595:2440:2;;;;4336:20209:5;15595:2440:2;;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;;;;;;;;;;;;;;;4336:20209:5;15595:2440:2;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;;15595:2440:2;15379:2662::o","linkReferences":{},"cborAuxdata":{},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":null,"blockNumber":null,"transactionIndex":null,"deployer":null},"sources":{"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/tokens/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple ERC20 + EIP-2612 implementation.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)\n///\n/// @dev Note:\n/// - The ERC20 standard allows minting and transferring to and from the zero address,\n///   minting and transferring zero tokens, as well as self-approvals.\n///   For performance, this implementation WILL NOT revert for such actions.\n///   Please add any checks with overrides if desired.\n/// - The `permit` function uses the ecrecover precompile (0x1).\n///\n/// If you are overriding:\n/// - NEVER violate the ERC20 invariant:\n///   the total sum of all balances must be equal to `totalSupply()`.\n/// - Check that the overridden function is actually used in the function you want to\n///   change the behavior of. Much of the code has been manually inlined for performance.\nabstract contract ERC20 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The total supply has overflowed.\n    error TotalSupplyOverflow();\n\n    /// @dev The allowance has overflowed.\n    error AllowanceOverflow();\n\n    /// @dev The allowance has underflowed.\n    error AllowanceUnderflow();\n\n    /// @dev Insufficient balance.\n    error InsufficientBalance();\n\n    /// @dev Insufficient allowance.\n    error InsufficientAllowance();\n\n    /// @dev The permit is invalid.\n    error InvalidPermit();\n\n    /// @dev The permit has expired.\n    error PermitExpired();\n\n    /// @dev The allowance of Permit2 is fixed at infinity.\n    error Permit2AllowanceIsFixedAtInfinity();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n\n    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.\n    event Approval(address indexed owner, address indexed spender, uint256 amount);\n\n    /// @dev `keccak256(bytes(\"Transfer(address,address,uint256)\"))`.\n    uint256 private constant _TRANSFER_EVENT_SIGNATURE =\n        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;\n\n    /// @dev `keccak256(bytes(\"Approval(address,address,uint256)\"))`.\n    uint256 private constant _APPROVAL_EVENT_SIGNATURE =\n        0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The storage slot for the total supply.\n    uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;\n\n    /// @dev The balance slot of `owner` is given by:\n    /// ```\n    ///     mstore(0x0c, _BALANCE_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let balanceSlot := keccak256(0x0c, 0x20)\n    /// ```\n    uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;\n\n    /// @dev The allowance slot of (`owner`, `spender`) is given by:\n    /// ```\n    ///     mstore(0x20, spender)\n    ///     mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let allowanceSlot := keccak256(0x0c, 0x34)\n    /// ```\n    uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;\n\n    /// @dev The nonce slot of `owner` is given by:\n    /// ```\n    ///     mstore(0x0c, _NONCES_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let nonceSlot := keccak256(0x0c, 0x20)\n    /// ```\n    uint256 private constant _NONCES_SLOT_SEED = 0x38377508;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev `(_NONCES_SLOT_SEED << 16) | 0x1901`.\n    uint256 private constant _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX = 0x383775081901;\n\n    /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n    bytes32 private constant _DOMAIN_TYPEHASH =\n        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n    /// @dev `keccak256(\"1\")`.\n    /// If you need to use a different version, override `_versionHash`.\n    bytes32 private constant _DEFAULT_VERSION_HASH =\n        0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;\n\n    /// @dev `keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\")`.\n    bytes32 private constant _PERMIT_TYPEHASH =\n        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n\n    /// @dev The canonical Permit2 address.\n    /// For signature-based allowance granting for single transaction ERC20 `transferFrom`.\n    /// To enable, override `_givePermit2InfiniteAllowance()`.\n    /// [Github](https://github.com/Uniswap/permit2)\n    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n    address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ERC20 METADATA                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the name of the token.\n    function name() public view virtual returns (string memory);\n\n    /// @dev Returns the symbol of the token.\n    function symbol() public view virtual returns (string memory);\n\n    /// @dev Returns the decimals places of the token.\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           ERC20                            */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the amount of tokens in existence.\n    function totalSupply() public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_TOTAL_SUPPLY_SLOT)\n        }\n    }\n\n    /// @dev Returns the amount of tokens owned by `owner`.\n    function balanceOf(address owner) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.\n    function allowance(address owner, address spender)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        if (_givePermit2InfiniteAllowance()) {\n            if (spender == _PERMIT2) return type(uint256).max;\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x34))\n        }\n    }\n\n    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n    ///\n    /// Emits a {Approval} event.\n    function approve(address spender, uint256 amount) public virtual returns (bool) {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && amount != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the allowance slot and store the amount.\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x34), amount)\n            // Emit the {Approval} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))\n        }\n        return true;\n    }\n\n    /// @dev Transfer `amount` tokens from the caller to `to`.\n    ///\n    /// Requirements:\n    /// - `from` must at least have `amount`.\n    ///\n    /// Emits a {Transfer} event.\n    function transfer(address to, uint256 amount) public virtual returns (bool) {\n        _beforeTokenTransfer(msg.sender, to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, caller())\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Compute the balance slot of `to`.\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance of `to`.\n            // Will not overflow because the sum of all user balances\n            // cannot exceed the maximum uint256 value.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(msg.sender, to, amount);\n        return true;\n    }\n\n    /// @dev Transfers `amount` tokens from `from` to `to`.\n    ///\n    /// Note: Does not update the allowance if it is the maximum uint256 value.\n    ///\n    /// Requirements:\n    /// - `from` must at least have `amount`.\n    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.\n    ///\n    /// Emits a {Transfer} event.\n    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {\n        _beforeTokenTransfer(from, to, amount);\n        // Code duplication is for zero-cost abstraction if possible.\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let from_ := shl(96, from)\n                if iszero(eq(caller(), _PERMIT2)) {\n                    // Compute the allowance slot and load its value.\n                    mstore(0x20, caller())\n                    mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n                    let allowanceSlot := keccak256(0x0c, 0x34)\n                    let allowance_ := sload(allowanceSlot)\n                    // If the allowance is not the maximum uint256 value.\n                    if not(allowance_) {\n                        // Revert if the amount to be transferred exceeds the allowance.\n                        if gt(amount, allowance_) {\n                            mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                            revert(0x1c, 0x04)\n                        }\n                        // Subtract and store the updated allowance.\n                        sstore(allowanceSlot, sub(allowance_, amount))\n                    }\n                }\n                // Compute the balance slot and load its value.\n                mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n                let fromBalanceSlot := keccak256(0x0c, 0x20)\n                let fromBalance := sload(fromBalanceSlot)\n                // Revert if insufficient balance.\n                if gt(amount, fromBalance) {\n                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated balance.\n                sstore(fromBalanceSlot, sub(fromBalance, amount))\n                // Compute the balance slot of `to`.\n                mstore(0x00, to)\n                let toBalanceSlot := keccak256(0x0c, 0x20)\n                // Add and store the updated balance of `to`.\n                // Will not overflow because the sum of all user balances\n                // cannot exceed the maximum uint256 value.\n                sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n                // Emit the {Transfer} event.\n                mstore(0x20, amount)\n                log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let from_ := shl(96, from)\n                // Compute the allowance slot and load its value.\n                mstore(0x20, caller())\n                mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n                let allowanceSlot := keccak256(0x0c, 0x34)\n                let allowance_ := sload(allowanceSlot)\n                // If the allowance is not the maximum uint256 value.\n                if not(allowance_) {\n                    // Revert if the amount to be transferred exceeds the allowance.\n                    if gt(amount, allowance_) {\n                        mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                        revert(0x1c, 0x04)\n                    }\n                    // Subtract and store the updated allowance.\n                    sstore(allowanceSlot, sub(allowance_, amount))\n                }\n                // Compute the balance slot and load its value.\n                mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n                let fromBalanceSlot := keccak256(0x0c, 0x20)\n                let fromBalance := sload(fromBalanceSlot)\n                // Revert if insufficient balance.\n                if gt(amount, fromBalance) {\n                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated balance.\n                sstore(fromBalanceSlot, sub(fromBalance, amount))\n                // Compute the balance slot of `to`.\n                mstore(0x00, to)\n                let toBalanceSlot := keccak256(0x0c, 0x20)\n                // Add and store the updated balance of `to`.\n                // Will not overflow because the sum of all user balances\n                // cannot exceed the maximum uint256 value.\n                sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n                // Emit the {Transfer} event.\n                mstore(0x20, amount)\n                log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n            }\n        }\n        _afterTokenTransfer(from, to, amount);\n        return true;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          EIP-2612                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For more performance, override to return the constant value\n    /// of `keccak256(bytes(name()))` if `name()` will never change.\n    function _constantNameHash() internal view virtual returns (bytes32 result) {}\n\n    /// @dev If you need a different value, override this function.\n    function _versionHash() internal view virtual returns (bytes32 result) {\n        result = _DEFAULT_VERSION_HASH;\n    }\n\n    /// @dev For inheriting contracts to increment the nonce.\n    function _incrementNonce(address owner) internal virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _NONCES_SLOT_SEED)\n            mstore(0x00, owner)\n            let nonceSlot := keccak256(0x0c, 0x20)\n            sstore(nonceSlot, add(1, sload(nonceSlot)))\n        }\n    }\n\n    /// @dev Returns the current nonce for `owner`.\n    /// This value is used to compute the signature for EIP-2612 permit.\n    function nonces(address owner) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the nonce slot and load its value.\n            mstore(0x0c, _NONCES_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Sets `value` as the allowance of `spender` over the tokens of `owner`,\n    /// authorized by a signed approval by `owner`.\n    ///\n    /// Emits a {Approval} event.\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && value != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(value)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Revert if the block timestamp is greater than `deadline`.\n            if gt(timestamp(), deadline) {\n                mstore(0x00, 0x1a15a3cc) // `PermitExpired()`.\n                revert(0x1c, 0x04)\n            }\n            let m := mload(0x40) // Grab the free memory pointer.\n            // Clean the upper 96 bits.\n            owner := shr(96, shl(96, owner))\n            spender := shr(96, shl(96, spender))\n            // Compute the nonce slot and load its value.\n            mstore(0x0e, _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX)\n            mstore(0x00, owner)\n            let nonceSlot := keccak256(0x0c, 0x20)\n            let nonceValue := sload(nonceSlot)\n            // Prepare the domain separator.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            mstore(0x2e, keccak256(m, 0xa0))\n            // Prepare the struct hash.\n            mstore(m, _PERMIT_TYPEHASH)\n            mstore(add(m, 0x20), owner)\n            mstore(add(m, 0x40), spender)\n            mstore(add(m, 0x60), value)\n            mstore(add(m, 0x80), nonceValue)\n            mstore(add(m, 0xa0), deadline)\n            mstore(0x4e, keccak256(m, 0xc0))\n            // Prepare the ecrecover calldata.\n            mstore(0x00, keccak256(0x2c, 0x42))\n            mstore(0x20, and(0xff, v))\n            mstore(0x40, r)\n            mstore(0x60, s)\n            let t := staticcall(gas(), 1, 0x00, 0x80, 0x20, 0x20)\n            // If the ecrecover fails, the returndatasize will be 0x00,\n            // `owner` will be checked if it equals the hash at 0x00,\n            // which evaluates to false (i.e. 0), and we will revert.\n            // If the ecrecover succeeds, the returndatasize will be 0x20,\n            // `owner` will be compared against the returned address at 0x20.\n            if iszero(eq(mload(returndatasize()), owner)) {\n                mstore(0x00, 0xddafbaef) // `InvalidPermit()`.\n                revert(0x1c, 0x04)\n            }\n            // Increment and store the updated nonce.\n            sstore(nonceSlot, add(nonceValue, t)) // `t` is 1 if ecrecover succeeds.\n            // Compute the allowance slot and store the value.\n            // The `owner` is already at slot 0x20.\n            mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))\n            sstore(keccak256(0x2c, 0x34), value)\n            // Emit the {Approval} event.\n            log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero pointer.\n        }\n    }\n\n    /// @dev Returns the EIP-712 domain separator for the EIP-2612 permit.\n    function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Grab the free memory pointer.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            result := keccak256(m, 0xa0)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  INTERNAL MINT FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Mints `amount` tokens to `to`, increasing the total supply.\n    ///\n    /// Emits a {Transfer} event.\n    function _mint(address to, uint256 amount) internal virtual {\n        _beforeTokenTransfer(address(0), to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)\n            let totalSupplyAfter := add(totalSupplyBefore, amount)\n            // Revert if the total supply overflows.\n            if lt(totalSupplyAfter, totalSupplyBefore) {\n                mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.\n                revert(0x1c, 0x04)\n            }\n            // Store the updated total supply.\n            sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(address(0), to, amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  INTERNAL BURN FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Burns `amount` tokens from `from`, reducing the total supply.\n    ///\n    /// Emits a {Transfer} event.\n    function _burn(address from, uint256 amount) internal virtual {\n        _beforeTokenTransfer(from, address(0), amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, from)\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Subtract and store the updated total supply.\n            sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))\n            // Emit the {Transfer} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)\n        }\n        _afterTokenTransfer(from, address(0), amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                INTERNAL TRANSFER FUNCTIONS                 */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Moves `amount` of tokens from `from` to `to`.\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        _beforeTokenTransfer(from, to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let from_ := shl(96, from)\n            // Compute the balance slot and load its value.\n            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Compute the balance slot of `to`.\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance of `to`.\n            // Will not overflow because the sum of all user balances\n            // cannot exceed the maximum uint256 value.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                INTERNAL ALLOWANCE FUNCTIONS                */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            if (spender == _PERMIT2) return; // Do nothing, as allowance is infinite.\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the allowance slot and load its value.\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            let allowanceSlot := keccak256(0x0c, 0x34)\n            let allowance_ := sload(allowanceSlot)\n            // If the allowance is not the maximum uint256 value.\n            if not(allowance_) {\n                // Revert if the amount to be transferred exceeds the allowance.\n                if gt(amount, allowance_) {\n                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated allowance.\n                sstore(allowanceSlot, sub(allowance_, amount))\n            }\n        }\n    }\n\n    /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.\n    ///\n    /// Emits a {Approval} event.\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && amount != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            let owner_ := shl(96, owner)\n            // Compute the allowance slot and store the amount.\n            mstore(0x20, spender)\n            mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))\n            sstore(keccak256(0x0c, 0x34), amount)\n            // Emit the {Approval} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     HOOKS TO OVERRIDE                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Hook that is called before any transfer of tokens.\n    /// This includes minting and burning.\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /// @dev Hook that is called after any transfer of tokens.\n    /// This includes minting and burning.\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          PERMIT2                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns whether to fix the Permit2 contract's allowance at infinity.\n    ///\n    /// This value should be kept constant after contract initialization,\n    /// or else the actual allowance values may not match with the {Approval} events.\n    /// For best performance, return a compile-time constant for zero-cost abstraction.\n    function _givePermit2InfiniteAllowance() internal view virtual returns (bool) {\n        return false;\n    }\n}\n"},"lib/solady/src/tokens/ERC20Votes.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {ERC20} from \"./ERC20.sol\";\n\n/// @notice ERC20 with votes based on ERC5805 and ERC6372.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20Votes.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Votes.sol)\nabstract contract ERC20Votes is ERC20 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The timepoint is in the future.\n    error ERC5805FutureLookup();\n\n    /// @dev The ERC5805 signature to set a delegate has expired.\n    error ERC5805DelegateSignatureExpired();\n\n    /// @dev The ERC5805 signature to set a delegate is invalid.\n    error ERC5805DelegateInvalidSignature();\n\n    /// @dev Out-of-bounds access for the checkpoints.\n    error ERC5805CheckpointIndexOutOfBounds();\n\n    /// @dev Arithmetic overflow when pushing a new checkpoint.\n    error ERC5805CheckpointValueOverflow();\n\n    /// @dev Arithmetic underflow when pushing a new checkpoint.\n    error ERC5805CheckpointValueUnderflow();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The delegate of `delegator` is changed from `from` to `to`.\n    event DelegateChanged(address indexed delegator, address indexed from, address indexed to);\n\n    /// @dev The votes balance of `delegate` is changed from `oldValue` to `newValue`.\n    event DelegateVotesChanged(address indexed delegate, uint256 oldValue, uint256 newValue);\n\n    /// @dev `keccak256(bytes(\"DelegateChanged(address,address,address)\"))`.\n    uint256 private constant _DELEGATE_CHANGED_EVENT_SIGNATURE =\n        0x3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f;\n\n    /// @dev `keccak256(bytes(\"DelegateVotesChanged(address,uint256,uint256)\"))`.\n    uint256 private constant _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE =\n        0xdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a724;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n    bytes32 private constant _DOMAIN_TYPEHASH =\n        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n    /// @dev `keccak256(\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\")`.\n    bytes32 private constant _ERC5805_DELEGATION_TYPEHASH =\n        0xe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The slot of a delegate is given by:\n    /// ```\n    ///     mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n    ///     mstore(0x00, account)\n    ///     let delegateSlot := keccak256(0x0c, 0x18)\n    /// ```\n    /// The checkpoints length slot of a delegate is given by:\n    /// ```\n    ///     mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n    ///     mstore(0x00, delegate)\n    ///     let lengthSlot := keccak256(0x0c, 0x17)\n    ///     let length := and(0xffffffffffff, shr(48, sload(lengthSlot)))\n    /// ```\n    /// The total checkpoints length slot is `_ERC20_VOTES_MASTER_SLOT_SEED << 96`.\n    ///\n    /// The `i`-th checkpoint slot is given by:\n    /// ```\n    ///     let checkpointSlot := add(i, lengthSlot)\n    ///     let key := and(sload(checkpointSlot), 0xffffffffffff)\n    ///     let value := shr(96, sload(checkpointSlot))\n    ///     if eq(value, address()) { value := sload(not(checkpointSlot)) }\n    /// ```\n    uint256 private constant _ERC20_VOTES_MASTER_SLOT_SEED = 0xff466c9f;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          ERC6372                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the clock mode.\n    function CLOCK_MODE() public view virtual returns (string memory) {\n        return \"mode=blocknumber&from=default\";\n    }\n\n    /// @dev Retusn the current clock.\n    function clock() public view returns (uint48 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := number()\n            // Branch-less out-of-gas revert if `block.number >= 2 ** 48`.\n            returndatacopy(returndatasize(), returndatasize(), sub(0, shr(48, number())))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          ERC5805                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the latest amount of voting units for `account`.\n    function getVotes(address account) public view virtual returns (uint256) {\n        return _checkpointLatest(_delegateCheckpointsSlot(account));\n    }\n\n    /// @dev Returns the latest amount of voting units `account` has before `timepoint`.\n    function getPastVotes(address account, uint256 timepoint)\n        public\n        view\n        virtual\n        returns (uint256)\n    {\n        if (timepoint >= clock()) _revertERC5805FutureLookup();\n        return _checkpointUpperLookupRecent(_delegateCheckpointsSlot(account), timepoint);\n    }\n\n    /// @dev Returns the current voting delegate of `delegator`.\n    function delegates(address delegator) public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, delegator)\n            result := sload(keccak256(0x0c, 0x18))\n        }\n    }\n\n    /// @dev Set the voting delegate of the caller to `delegatee`.\n    function delegate(address delegatee) public virtual {\n        _delegate(msg.sender, delegatee);\n    }\n\n    /// @dev Sets the voting delegate of the signature signer to `delegatee`.\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        address signer;\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if gt(timestamp(), expiry) {\n                mstore(0x00, 0x3480e9e1) // `ERC5805DelegateSignatureExpired()`.\n                revert(0x1c, 0x04)\n            }\n            let m := mload(0x40)\n            // Prepare the struct hash.\n            mstore(0x00, _ERC5805_DELEGATION_TYPEHASH)\n            mstore(0x20, shr(96, shl(96, delegatee)))\n            mstore(0x40, nonce)\n            mstore(0x60, expiry)\n            mstore(0x40, keccak256(0x00, 0x80))\n            mstore(0x00, 0x1901) // Store \"\\x19\\x01\".\n            // Prepare the domain separator.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            mstore(0x20, keccak256(m, 0xa0))\n            // Prepare the ecrecover calldata.\n            mstore(0x00, keccak256(0x1e, 0x42))\n            mstore(0x20, and(0xff, v))\n            mstore(0x40, r)\n            mstore(0x60, s)\n            signer := mload(staticcall(gas(), 1, 0x00, 0x80, 0x01, 0x20))\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero pointer.\n            // `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.\n            expiry := iszero(returndatasize()) // Reuse `expiry` to denote `ecrecover` failure.\n        }\n        if ((nonces(signer) ^ nonce) | expiry != 0) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                mstore(0x00, 0x1838d95c) // `ERC5805DelegateInvalidSignature()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _incrementNonce(signer);\n        _delegate(signer, delegatee);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*              OTHER VOTE PUBLIC VIEW FUNCTIONS              */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the number of checkpoints for `account`.\n    function checkpointCount(address account) public view virtual returns (uint256 result) {\n        result = _delegateCheckpointsSlot(account);\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(208, shl(160, sload(result)))\n        }\n    }\n\n    /// @dev Returns the voting checkpoint for `account` at index `i`.\n    function checkpointAt(address account, uint256 i)\n        public\n        view\n        virtual\n        returns (uint48 checkpointClock, uint256 checkpointValue)\n    {\n        uint256 lengthSlot = _delegateCheckpointsSlot(account);\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(lt(i, shr(208, shl(160, sload(lengthSlot))))) {\n                mstore(0x00, 0x86df9d10) // `ERC5805CheckpointIndexOutOfBounds()`.\n                revert(0x1c, 0x04)\n            }\n            let checkpointPacked := sload(add(i, lengthSlot))\n            checkpointClock := and(0xffffffffffff, checkpointPacked)\n            checkpointValue := shr(96, checkpointPacked)\n            if eq(checkpointValue, address()) { checkpointValue := sload(not(add(i, lengthSlot))) }\n        }\n    }\n\n    /// @dev Returns the latest amount of total voting units.\n    function getVotesTotalSupply() public view virtual returns (uint256) {\n        return _checkpointLatest(_ERC20_VOTES_MASTER_SLOT_SEED << 96);\n    }\n\n    /// @dev Returns the latest amount of total voting units before `timepoint`.\n    function getPastVotesTotalSupply(uint256 timepoint) public view virtual returns (uint256) {\n        if (timepoint >= clock()) _revertERC5805FutureLookup();\n        return _checkpointUpperLookupRecent(_ERC20_VOTES_MASTER_SLOT_SEED << 96, timepoint);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the amount of voting units `delegator` has control over.\n    /// Override if you need a different formula.\n    function _getVotingUnits(address delegator) internal view virtual returns (uint256) {\n        return balanceOf(delegator);\n    }\n\n    /// @dev ERC20 after token transfer internal hook.\n    function _afterTokenTransfer(address from, address to, uint256 amount)\n        internal\n        virtual\n        override\n    {\n        _transferVotingUnits(from, to, amount);\n    }\n\n    /// @dev Used in `_afterTokenTransfer(address from, address to, uint256 amount)`.\n    function _transferVotingUnits(address from, address to, uint256 amount) internal virtual {\n        if (from == address(0)) {\n            _checkpointPushDiff(_ERC20_VOTES_MASTER_SLOT_SEED << 96, clock(), amount, true);\n        }\n        if (to == address(0)) {\n            _checkpointPushDiff(_ERC20_VOTES_MASTER_SLOT_SEED << 96, clock(), amount, false);\n        }\n        _moveDelegateVotes(delegates(from), delegates(to), amount);\n    }\n\n    /// @dev Transfer `amount` of delegated votes from `from` to `to`.\n    /// Emits a {DelegateVotesChanged} event for each change of delegated votes.\n    function _moveDelegateVotes(address from, address to, uint256 amount) internal virtual {\n        if (amount == uint256(0)) return;\n        (uint256 fromCleaned, uint256 toCleaned) = (uint256(uint160(from)), uint256(uint160(to)));\n        if (fromCleaned == toCleaned) return;\n        if (fromCleaned != 0) {\n            (uint256 oldValue, uint256 newValue) =\n                _checkpointPushDiff(_delegateCheckpointsSlot(from), clock(), amount, false);\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Emit the {DelegateVotesChanged} event.\n                mstore(0x00, oldValue)\n                mstore(0x20, newValue)\n                log2(0x00, 0x40, _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE, fromCleaned)\n            }\n        }\n        if (toCleaned != 0) {\n            (uint256 oldValue, uint256 newValue) =\n                _checkpointPushDiff(_delegateCheckpointsSlot(to), clock(), amount, true);\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Emit the {DelegateVotesChanged} event.\n                mstore(0x00, oldValue)\n                mstore(0x20, newValue)\n                log2(0x00, 0x40, _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE, toCleaned)\n            }\n        }\n    }\n\n    /// @dev Delegates all of `account`'s voting units to `delegatee`.\n    /// Emits the {DelegateChanged} and {DelegateVotesChanged} events.\n    function _delegate(address account, address delegatee) internal virtual {\n        address from;\n        /// @solidity memory-safe-assembly\n        assembly {\n            let to := shr(96, shl(96, delegatee))\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, account)\n            let delegateSlot := keccak256(0x0c, 0x18)\n            from := sload(delegateSlot)\n            sstore(delegateSlot, to)\n            // Emit the {DelegateChanged} event.\n            log4(0x00, 0x00, _DELEGATE_CHANGED_EVENT_SIGNATURE, shr(96, mload(0x0c)), from, to)\n        }\n        _moveDelegateVotes(from, delegatee, _getVotingUnits(account));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the delegate checkpoints slot for `account`.\n    function _delegateCheckpointsSlot(address account) private pure returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, account)\n            result := keccak256(0x0c, 0x17)\n        }\n    }\n\n    /// @dev Pushes a checkpoint.\n    function _checkpointPushDiff(uint256 lengthSlot, uint256 key, uint256 amount, bool isAdd)\n        private\n        returns (uint256 oldValue, uint256 newValue)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let lengthSlotPacked := sload(lengthSlot)\n            for { let n := shr(208, shl(160, lengthSlotPacked)) } 1 {} {\n                if iszero(n) {\n                    if iszero(or(isAdd, iszero(amount))) {\n                        mstore(0x00, 0x5915f686) // `ERC5805CheckpointValueUnderflow()`.\n                        revert(0x1c, 0x04)\n                    }\n                    newValue := amount\n                    if iszero(or(eq(newValue, address()), shr(160, newValue))) {\n                        sstore(lengthSlot, or(or(key, shl(48, 1)), shl(96, newValue)))\n                        break\n                    }\n                    sstore(lengthSlot, or(or(key, shl(48, 1)), shl(96, address())))\n                    sstore(not(lengthSlot), newValue)\n                    break\n                }\n                let checkpointSlot := add(sub(n, 1), lengthSlot)\n                let lastPacked := sload(checkpointSlot)\n                oldValue := shr(96, lastPacked)\n                if eq(oldValue, address()) { oldValue := sload(not(checkpointSlot)) }\n                for {} 1 {} {\n                    if iszero(isAdd) {\n                        newValue := sub(oldValue, amount)\n                        if iszero(gt(newValue, oldValue)) { break }\n                        mstore(0x00, 0x5915f686) // `ERC5805CheckpointValueUnderflow()`.\n                        revert(0x1c, 0x04)\n                    }\n                    newValue := add(oldValue, amount)\n                    if iszero(lt(newValue, oldValue)) { break }\n                    mstore(0x00, 0x9dbbeb75) // `ERC5805CheckpointValueOverflow()`.\n                    revert(0x1c, 0x04)\n                }\n                let lastKey := and(0xffffffffffff, lastPacked)\n                if iszero(eq(lastKey, key)) {\n                    n := add(1, n)\n                    checkpointSlot := add(1, checkpointSlot)\n                    sstore(lengthSlot, add(shl(48, 1), lengthSlotPacked))\n                }\n                if or(gt(lastKey, key), shr(48, n)) { invalid() }\n                if iszero(or(eq(newValue, address()), shr(160, newValue))) {\n                    sstore(checkpointSlot, or(or(key, shl(48, n)), shl(96, newValue)))\n                    break\n                }\n                sstore(checkpointSlot, or(or(key, shl(48, n)), shl(96, address())))\n                sstore(not(checkpointSlot), newValue)\n                break\n            }\n        }\n    }\n\n    /// @dev Returns the latest value in the checkpoints.\n    function _checkpointLatest(uint256 lengthSlot) private view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(208, shl(160, sload(lengthSlot)))\n            if result {\n                lengthSlot := add(sub(result, 1), lengthSlot) // Reuse for `checkpointSlot`.\n                result := shr(96, sload(lengthSlot))\n                if eq(result, address()) { result := sload(not(lengthSlot)) }\n            }\n        }\n    }\n\n    /// @dev Returns the value in the checkpoints with the largest key that is less than `key`.\n    function _checkpointUpperLookupRecent(uint256 lengthSlot, uint256 key)\n        private\n        view\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let l := 0 // Low.\n            let h := shr(208, shl(160, sload(lengthSlot))) // High.\n            // Start the binary search nearer to the right to optimize for recent checkpoints.\n            for {} iszero(lt(h, 6)) {} {\n                let m := shl(4, lt(0xffff, h))\n                m := shl(shr(1, or(m, shl(3, lt(0xff, shr(m, h))))), 16)\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := sub(h, shr(1, add(m, div(h, m)))) // Approx `h - sqrt(h)`.\n                if iszero(lt(key, and(sload(add(m, lengthSlot)), 0xffffffffffff))) {\n                    l := add(1, m)\n                    break\n                }\n                h := m\n                break\n            }\n            // Binary search.\n            for {} lt(l, h) {} {\n                let m := shr(1, add(l, h)) // Won't overflow in practice.\n                if iszero(lt(key, and(sload(add(m, lengthSlot)), 0xffffffffffff))) {\n                    l := add(1, m)\n                    continue\n                }\n                h := m\n            }\n            let checkpointSlot := add(sub(h, 1), lengthSlot)\n            result := mul(iszero(iszero(h)), shr(96, sload(checkpointSlot)))\n            if eq(result, address()) { result := sload(not(checkpointSlot)) }\n        }\n    }\n\n    /// @dev Reverts with `ERC5805FutureLookup()`.\n    function _revertERC5805FutureLookup() private pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0xf9874464) // `ERC5805FutureLookup()`.\n            revert(0x1c, 0x04)\n        }\n    }\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 _INTIALIZED_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    /*                         OPERATIONS                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return a 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, _INTIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Guards an reinitialzer 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            version := and(version, 0xffffffffffffffff) // Clean upper bits.\n            let i := sload(s)\n            // If `initializing == 1 || initializedVersion >= version`.\n            if iszero(lt(and(i, 1), lt(shr(1, 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, shl(1, version)))\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Set `initializing` to 0, `initializedVersion` to `version`.\n            sstore(s, shl(1, version))\n            // Emit the {Initialized} event.\n            mstore(0x20, version)\n            log1(0x20, 0x20, _INTIALIZED_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 := shr(192, s) // Computed to save bytecode.\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, _INTIALIZED_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/LibTransient.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Library for RLP encoding and CREATE address computation.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibTransient.sol)\n/// @author Modified from Transient Goodies by Philogy (https://github.com/Philogy/transient-goodies/blob/main/src/TransientBytesLib.sol)\n///\n/// @dev Note: The functions postfixed with `Compat` will only use transient storage on L1.\n/// L2s are super cheap anyway.\n/// For best safety, always clear the storage after use.\nlibrary LibTransient {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STRUCTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Pointer struct to a `uint256` in transient storage.\n    struct TUint256 {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `int256` in transient storage.\n    struct TInt256 {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `bytes32` in transient storage.\n    struct TBytes32 {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `address` in transient storage.\n    struct TAddress {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `bool` in transient storage.\n    struct TBool {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `bytes` in transient storage.\n    struct TBytes {\n        uint256 _spacer;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The storage slot seed for converting a transient slot to a storage slot.\n    /// `bytes4(keccak256(\"_LIB_TRANSIENT_COMPAT_SLOT_SEED\"))`.\n    uint256 private constant _LIB_TRANSIENT_COMPAT_SLOT_SEED = 0x5a0b45f2;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     UINT256 OPERATIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `uint256` in transient storage.\n    function tUint256(bytes32 tSlot) internal pure returns (TUint256 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `uint256` in transient storage.\n    function tUint256(uint256 tSlot) internal pure returns (TUint256 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TUint256 storage ptr) internal view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TUint256 storage ptr) internal view returns (uint256 result) {\n        result = block.chainid == 1 ? get(ptr) : _compat(ptr)._spacer;\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TUint256 storage ptr, uint256 value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, value)\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TUint256 storage ptr, uint256 value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        _compat(ptr)._spacer = value;\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TUint256 storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TUint256 storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /// @dev Increments the value at transient `ptr` by 1.\n    function inc(TUint256 storage ptr) internal returns (uint256 newValue) {\n        set(ptr, newValue = get(ptr) + 1);\n    }\n\n    /// @dev Increments the value at transient `ptr` by 1.\n    function incCompat(TUint256 storage ptr) internal returns (uint256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) + 1);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function inc(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {\n        set(ptr, newValue = get(ptr) + delta);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function incCompat(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) + delta);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by 1.\n    function dec(TUint256 storage ptr) internal returns (uint256 newValue) {\n        set(ptr, newValue = get(ptr) - 1);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decCompat(TUint256 storage ptr) internal returns (uint256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) - 1);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function dec(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {\n        set(ptr, newValue = get(ptr) - delta);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decCompat(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) - delta);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function incSigned(TUint256 storage ptr, int256 delta) internal returns (uint256 newValue) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let currentValue := tload(ptr.slot)\n            newValue := add(currentValue, delta)\n            if iszero(eq(lt(newValue, currentValue), slt(delta, 0))) {\n                mstore(0x00, 0x4e487b71) // `Panic(uint256)`.\n                mstore(0x20, 0x11) // Underflow or overflow panic.\n                revert(0x1c, 0x24)\n            }\n            tstore(ptr.slot, newValue)\n        }\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function incSignedCompat(TUint256 storage ptr, int256 delta)\n        internal\n        returns (uint256 newValue)\n    {\n        if (block.chainid == 1) return incSigned(ptr, delta);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let currentValue := sload(ptr.slot)\n            newValue := add(currentValue, delta)\n            if iszero(eq(lt(newValue, currentValue), slt(delta, 0))) {\n                mstore(0x00, 0x4e487b71) // `Panic(uint256)`.\n                mstore(0x20, 0x11) // Underflow or overflow panic.\n                revert(0x1c, 0x24)\n            }\n            sstore(ptr.slot, newValue)\n        }\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decSigned(TUint256 storage ptr, int256 delta) internal returns (uint256 newValue) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let currentValue := tload(ptr.slot)\n            newValue := sub(currentValue, delta)\n            if iszero(eq(lt(newValue, currentValue), sgt(delta, 0))) {\n                mstore(0x00, 0x4e487b71) // `Panic(uint256)`.\n                mstore(0x20, 0x11) // Underflow or overflow panic.\n                revert(0x1c, 0x24)\n            }\n            tstore(ptr.slot, newValue)\n        }\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decSignedCompat(TUint256 storage ptr, int256 delta)\n        internal\n        returns (uint256 newValue)\n    {\n        if (block.chainid == 1) return decSigned(ptr, delta);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let currentValue := sload(ptr.slot)\n            newValue := sub(currentValue, delta)\n            if iszero(eq(lt(newValue, currentValue), sgt(delta, 0))) {\n                mstore(0x00, 0x4e487b71) // `Panic(uint256)`.\n                mstore(0x20, 0x11) // Underflow or overflow panic.\n                revert(0x1c, 0x24)\n            }\n            sstore(ptr.slot, newValue)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INT256 OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `int256` in transient storage.\n    function tInt256(bytes32 tSlot) internal pure returns (TInt256 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `int256` in transient storage.\n    function tInt256(uint256 tSlot) internal pure returns (TInt256 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TInt256 storage ptr) internal view returns (int256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TInt256 storage ptr) internal view returns (int256 result) {\n        result = block.chainid == 1 ? get(ptr) : int256(_compat(ptr)._spacer);\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TInt256 storage ptr, int256 value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, value)\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TInt256 storage ptr, int256 value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        _compat(ptr)._spacer = uint256(value);\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TInt256 storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TInt256 storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /// @dev Increments the value at transient `ptr` by 1.\n    function inc(TInt256 storage ptr) internal returns (int256 newValue) {\n        set(ptr, newValue = get(ptr) + 1);\n    }\n\n    /// @dev Increments the value at transient `ptr` by 1.\n    function incCompat(TInt256 storage ptr) internal returns (int256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) + 1);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function inc(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {\n        set(ptr, newValue = get(ptr) + delta);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function incCompat(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) + delta);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by 1.\n    function dec(TInt256 storage ptr) internal returns (int256 newValue) {\n        set(ptr, newValue = get(ptr) - 1);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by 1.\n    function decCompat(TInt256 storage ptr) internal returns (int256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) - 1);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function dec(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {\n        set(ptr, newValue = get(ptr) - delta);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decCompat(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) - delta);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     BYTES32 OPERATIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `bytes32` in transient storage.\n    function tBytes32(bytes32 tSlot) internal pure returns (TBytes32 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `bytes32` in transient storage.\n    function tBytes32(uint256 tSlot) internal pure returns (TBytes32 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TBytes32 storage ptr) internal view returns (bytes32 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TBytes32 storage ptr) internal view returns (bytes32 result) {\n        result = block.chainid == 1 ? get(ptr) : bytes32(_compat(ptr)._spacer);\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TBytes32 storage ptr, bytes32 value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, value)\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TBytes32 storage ptr, bytes32 value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        _compat(ptr)._spacer = uint256(value);\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TBytes32 storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TBytes32 storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     ADDRESS OPERATIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `address` in transient storage.\n    function tAddress(bytes32 tSlot) internal pure returns (TAddress storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `address` in transient storage.\n    function tAddress(uint256 tSlot) internal pure returns (TAddress storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TAddress storage ptr) internal view returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TAddress storage ptr) internal view returns (address result) {\n        result = block.chainid == 1 ? get(ptr) : address(uint160(_compat(ptr)._spacer));\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TAddress storage ptr, address value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, shr(96, shl(96, value)))\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TAddress storage ptr, address value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        _compat(ptr)._spacer = uint160(value);\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TAddress storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TAddress storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      BOOL OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `bool` in transient storage.\n    function tBool(bytes32 tSlot) internal pure returns (TBool storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `bool` in transient storage.\n    function tBool(uint256 tSlot) internal pure returns (TBool storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TBool storage ptr) internal view returns (bool result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TBool storage ptr) internal view returns (bool result) {\n        result = block.chainid == 1 ? get(ptr) : _compat(ptr)._spacer != 0;\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TBool storage ptr, bool value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, iszero(iszero(value)))\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TBool storage ptr, bool value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            sstore(ptr.slot, iszero(iszero(value)))\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TBool storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TBool storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      BYTES OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `bytes` in transient storage.\n    function tBytes(bytes32 tSlot) internal pure returns (TBytes storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `bytes` in transient storage.\n    function tBytes(uint256 tSlot) internal pure returns (TBytes storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the length of the bytes stored at transient `ptr`.\n    function length(TBytes storage ptr) internal view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(224, tload(ptr.slot))\n        }\n    }\n\n    /// @dev Returns the length of the bytes stored at transient `ptr`.\n    function lengthCompat(TBytes storage ptr) internal view returns (uint256 result) {\n        if (block.chainid == 1) return length(ptr);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(224, sload(ptr.slot))\n        }\n    }\n\n    /// @dev Returns the bytes stored at transient `ptr`.\n    function get(TBytes storage ptr) internal view returns (bytes memory result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := mload(0x40)\n            mstore(result, 0x00)\n            mstore(add(result, 0x1c), tload(ptr.slot)) // Length and first `0x1c` bytes.\n            let n := mload(result)\n            let e := add(add(result, 0x20), n)\n            if iszero(lt(n, 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let d := sub(keccak256(0x00, 0x20), result)\n                for { let o := add(result, 0x3c) } 1 {} {\n                    mstore(o, tload(add(o, d)))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n            mstore(e, 0) // Zeroize the slot after the string.\n            mstore(0x40, add(0x20, e)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the bytes stored at transient `ptr`.\n    function getCompat(TBytes storage ptr) internal view returns (bytes memory result) {\n        if (block.chainid == 1) return get(ptr);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := mload(0x40)\n            mstore(result, 0x00)\n            mstore(add(result, 0x1c), sload(ptr.slot)) // Length and first `0x1c` bytes.\n            let n := mload(result)\n            let e := add(add(result, 0x20), n)\n            if iszero(lt(n, 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let d := sub(keccak256(0x00, 0x20), result)\n                for { let o := add(result, 0x3c) } 1 {} {\n                    mstore(o, sload(add(o, d)))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n            mstore(e, 0) // Zeroize the slot after the string.\n            mstore(0x40, add(0x20, e)) // Allocate memory.\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TBytes storage ptr, bytes memory value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, mload(add(value, 0x1c)))\n            if iszero(lt(mload(value), 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let e := add(add(value, 0x20), mload(value))\n                let d := sub(keccak256(0x00, or(0x20, sub(0, shr(32, mload(value))))), value)\n                for { let o := add(value, 0x3c) } 1 {} {\n                    tstore(add(o, d), mload(o))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TBytes storage ptr, bytes memory value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            sstore(ptr.slot, mload(add(value, 0x1c)))\n            if iszero(lt(mload(value), 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let e := add(add(value, 0x20), mload(value))\n                let d := sub(keccak256(0x00, or(0x20, sub(0, shr(32, mload(value))))), value)\n                for { let o := add(value, 0x3c) } 1 {} {\n                    sstore(add(o, d), mload(o))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCalldata(TBytes storage ptr, bytes calldata value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, calldataload(sub(value.offset, 0x04)))\n            if iszero(lt(value.length, 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let e := add(value.offset, value.length)\n                // forgefmt: disable-next-item\n                let d := add(sub(keccak256(0x00, or(0x20, sub(0, shr(32, value.length)))),\n                    value.offset), 0x20)\n                for { let o := add(value.offset, 0x1c) } 1 {} {\n                    tstore(add(o, d), calldataload(o))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCalldataCompat(TBytes storage ptr, bytes calldata value) internal {\n        if (block.chainid == 1) return setCalldata(ptr, value);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            sstore(ptr.slot, calldataload(sub(value.offset, 0x04)))\n            if iszero(lt(value.length, 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let e := add(value.offset, value.length)\n                // forgefmt: disable-next-item\n                let d := add(sub(keccak256(0x00, or(0x20, sub(0, shr(32, value.length)))),\n                    value.offset), 0x20)\n                for { let o := add(value.offset, 0x1c) } 1 {} {\n                    sstore(add(o, d), calldataload(o))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TBytes storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TBytes storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TUint256 storage ptr) private pure returns (TUint256 storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TInt256 storage ptr) private pure returns (TInt256 storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TBytes32 storage ptr) private pure returns (TBytes32 storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TAddress storage ptr) private pure returns (TAddress storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TBool storage ptr) private pure returns (TBool storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TBytes storage ptr) private pure returns (TBytes storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n}\n"},"src/tokens/DopplerERC20V1.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.24;\n\nimport { Ownable } from \"solady/auth/Ownable.sol\";\nimport { ERC20 } from \"solady/tokens/ERC20.sol\";\nimport { ERC20Votes } from \"solady/tokens/ERC20Votes.sol\";\nimport { Initializable } from \"solady/utils/Initializable.sol\";\nimport { LibTransient } from \"solady/utils/LibTransient.sol\";\nimport { WAD } from \"src/types/Wad.sol\";\n\n/// @dev Thrown when two arrays have different lengths\nerror ArrayLengthsMismatch();\n\n/// @dev Thrown when trying to transfer tokens into the pool while it is locked\nerror PoolLocked();\n\n/// @dev Thrown when trying to lock the pool while it is already locked\nerror PoolAlreadyLocked();\n\n/// @dev Thrown when trying to unlock the pool while it is already unlocked\nerror PoolAlreadyUnlocked();\n\n/// @dev Thrown when there is no releasable amount\nerror NoReleasableAmount();\n\n/// @dev Thrown when the balance limit is not active\nerror BalanceLimitNotActive();\n\n/// @dev Thrown when the schedule ID is out of range\nerror UnknownScheduleId(uint256 scheduleId);\n\n/// @dev Thrown when a schedule is invalid (violates duration/cliff constraints)\nerror InvalidSchedule(uint256 scheduleId);\n\n/// @dev Thrown when an allocation is invalid (zero address or zero amount)\nerror InvalidAllocation(uint256 index);\n\n/// @dev Thrown when the specified balance limit timestamp is in the past\nerror InvalidBalanceLimitTimestamp(uint256 specified, uint256 current);\n\n/// @dev Thrown when the specified balance limit wad is invalid\nerror InvalidBalanceLimit(uint256 limit);\n\n/// @dev Thrown when an address's balance exceeds the balance limit\nerror BalanceLimitExceeded(uint256 balance, uint256 limit);\n\n/// @dev Thrown when the requested amount is greater than the available amount\nerror InsufficientReleasableAmount(uint256 available, uint256 requested);\n\n/// @dev Thrown when trying to premint more than the maximum allowed per address\nerror MaxPreMintPerAddressExceeded(uint256 amount, uint256 limit);\n\n/// @dev Thrown when trying to premint more than the maximum allowed in total\nerror MaxTotalPreMintExceeded(uint256 amount, uint256 limit);\n\n/// @dev Thrown when trying to mint more than the maximum allowed in total\nerror MaxTotalVestedExceeded(uint256 amount, uint256 limit);\n\n/// @dev Max amount of tokens that can be pre-minted per address (% expressed in WAD)\nuint256 constant MAX_PRE_MINT_PER_ADDRESS_WAD = 0.8 ether;\n\n/// @dev Max amount of tokens that can be pre-minted in total (% expressed in WAD)\nuint256 constant MAX_TOTAL_PRE_MINT_WAD = 0.8 ether;\n\n/// @dev Minimum vesting duration (prevents trivially short vesting periods)\nuint256 constant MIN_VESTING_DURATION = 1 days;\n\n/// @dev Transient storage namespace for initializer schedule deduplication\nbytes32 constant HAS_SCHEDULE_TRANSIENT_SLOT = keccak256(\"doppler.DopplerERC20V1.hasSchedule.transient\");\n\n/**\n * @notice Vesting schedule definition\n * @param cliff Seconds after vestingStart until tokens become claimable\n * @param duration Seconds after vestingStart until fully vested\n */\nstruct VestingSchedule {\n    uint64 cliff;\n    uint64 duration;\n}\n\n/**\n * @notice Vesting data for a specific address\n * @param totalAmount Total amount of vested tokens\n * @param releasedAmount Amount of tokens already released\n */\nstruct VestingData {\n    uint256 totalAmount;\n    uint256 releasedAmount;\n}\n\n/// @notice Emitted when a new vesting schedule is created\nevent VestingScheduleCreated(uint256 indexed scheduleId, uint64 cliff, uint64 duration);\n\n/// @notice Emitted when tokens are allocated to a beneficiary under a schedule\nevent VestingAllocated(address indexed beneficiary, uint256 indexed scheduleId, uint256 amount);\n\n/// @notice Emitted when tokens are released to a beneficiary\nevent TokensReleased(address indexed beneficiary, uint256 indexed scheduleId, uint256 amount);\n\n/// @notice Emitted when the token URI is updated\nevent UpdateTokenURI(string tokenURI);\n\n/// @notice Emitted when the balance limit is disabled\nevent BalanceLimitDisabled(bool expired);\n\n/**\n * @title DopplerERC20 V1.0.0\n * @author Whetstone Research\n * @notice Clonable ERC20 token with multi-schedule vesting, pool lock, votes, max balance limit, and Permit2 support\n * @dev This contract is designed to be cloned using the ERC1167 minimal proxy pattern\n * @custom:security-contact security@whetstone.cc\n */\ncontract DopplerERC20V1 is ERC20, Initializable, Ownable, ERC20Votes {\n    /// @dev Name of the token\n    string private _name;\n\n    /// @dev Symbol of the token\n    string private _symbol;\n\n    /// @notice Uniform Resource Identifier (URI)\n    string public tokenURI;\n\n    /// @notice Timestamp of the start of all vesting schedules\n    uint256 public vestingStart;\n\n    /// @notice Total amount of vested tokens across all beneficiaries and schedules\n    uint256 public vestedTotalAmount;\n\n    /// @notice Controller address (can disable the balance limit)\n    address public controller;\n\n    /// @notice Address of the liquidity pool\n    address public pool;\n\n    /// @notice Whether the pool can receive tokens (unlocked) or not\n    bool public isPoolLocked;\n\n    /// @notice Whether the balance limit is active or not\n    bool public isBalanceLimitActive;\n\n    /// @notice Balance limit end timestamp (in seconds)\n    uint48 public balanceLimitEnd;\n\n    /// @notice Maximum balance limit\n    uint256 public maxBalanceLimit;\n\n    /// @notice Array of vesting schedules (scheduleId = index)\n    VestingSchedule[] public vestingSchedules;\n\n    /// @notice Vesting data for each (beneficiary, scheduleId) pair\n    mapping(address beneficiary => mapping(uint256 scheduleId => VestingData)) public vestingOf;\n\n    /// @notice Total allocated amount per beneficiary (for cap enforcement)\n    mapping(address beneficiary => uint256) public totalAllocatedOf;\n\n    /// @notice List of schedule IDs for each beneficiary\n    mapping(address beneficiary => uint256[]) internal _scheduleIdsOf;\n\n    /// @notice Whether an address is excluded from the balance limit\n    mapping(address account => bool excluded) public isExcludedFromBalanceLimit;\n\n    modifier onlyController() {\n        require(msg.sender == controller, Unauthorized());\n        _;\n    }\n\n    constructor() {\n        _disableInitializers();\n    }\n\n    /**\n     * @notice Initializes the token with the given parameters\n     * @param name_ Name of the token\n     * @param symbol_ Symbol of the token\n     * @param initialSupply Initial supply of the token\n     * @param recipient Address receiving the non-vested initial supply\n     * @param owner_ Address receiving the ownership of the token\n     * @param schedules Array of vesting schedules\n     * @param beneficiaries Array of beneficiary addresses for allocations\n     * @param scheduleIds Array of schedule IDs corresponding to each allocation\n     * @param amounts Array of amounts for each allocation\n     * @param tokenURI_ Uniform Resource Identifier (URI)\n     * @param maxBalanceLimit_ Maximum balance limit\n     * @param balanceLimitEnd_ Balance limit end timestamp\n     * @param controller_ Controller address (optional, excluding it prevents disabling the balance limit earlier)\n     * @param excludedFromBalanceLimit Array of addresses to exclude from the balance limit.\n     *                                 This should include initializers, migrators, Uniswap PoolManager, treasury, etc.\n     */\n    function initialize(\n        string memory name_,\n        string memory symbol_,\n        uint256 initialSupply,\n        address recipient,\n        address owner_,\n        VestingSchedule[] memory schedules,\n        address[] memory beneficiaries,\n        uint256[] memory scheduleIds,\n        uint256[] memory amounts,\n        string memory tokenURI_,\n        uint256 maxBalanceLimit_,\n        uint48 balanceLimitEnd_,\n        address controller_,\n        address[] memory excludedFromBalanceLimit\n    ) external initializer {\n        _initializeOwner(owner_);\n\n        _name = name_;\n        _symbol = symbol_;\n        vestingStart = block.timestamp;\n        tokenURI = tokenURI_;\n\n        if (balanceLimitEnd_ > 0 || maxBalanceLimit_ > 0) {\n            require(maxBalanceLimit_ > 0 && maxBalanceLimit_ < initialSupply, InvalidBalanceLimit(maxBalanceLimit_));\n            require(balanceLimitEnd_ > block.timestamp, InvalidBalanceLimitTimestamp(balanceLimitEnd_, block.timestamp));\n\n            maxBalanceLimit = maxBalanceLimit_;\n            balanceLimitEnd = balanceLimitEnd_;\n            controller = controller_;\n            isBalanceLimitActive = true;\n            isExcludedFromBalanceLimit[owner_] = true;\n            isExcludedFromBalanceLimit[recipient] = true;\n\n            uint256 excludedLength = excludedFromBalanceLimit.length;\n            for (uint256 i; i < excludedLength; ++i) {\n                isExcludedFromBalanceLimit[excludedFromBalanceLimit[i]] = true;\n            }\n        }\n\n        // Validate allocation array lengths\n        uint256 allocationLength = beneficiaries.length;\n        require(allocationLength == scheduleIds.length && allocationLength == amounts.length, ArrayLengthsMismatch());\n\n        // Validate and store schedules\n        uint256 schedulesLength = schedules.length;\n        for (uint256 i; i < schedulesLength; i++) {\n            VestingSchedule memory s = schedules[i];\n            // Duration must be 0 (instant vest) or >= MIN_VESTING_DURATION\n            // Cliff must be <= duration\n            require(\n                (s.duration == 0 || s.duration >= MIN_VESTING_DURATION) && s.cliff <= s.duration, InvalidSchedule(i)\n            );\n            vestingSchedules.push(s);\n            emit VestingScheduleCreated(i, s.cliff, s.duration);\n        }\n\n        // Compute caps\n        uint256 maxPreMintPerAddress = initialSupply * MAX_PRE_MINT_PER_ADDRESS_WAD / WAD;\n        uint256 maxTotalPreMint = initialSupply * MAX_TOTAL_PRE_MINT_WAD / WAD;\n\n        // Process allocations\n        uint256 vestedTokens;\n        for (uint256 i; i < allocationLength; i++) {\n            address beneficiary = beneficiaries[i];\n            uint256 scheduleId = scheduleIds[i];\n            uint256 amount = amounts[i];\n\n            // Validate allocation\n            require(beneficiary != address(0) && amount > 0, InvalidAllocation(i));\n            require(scheduleId < schedulesLength, UnknownScheduleId(scheduleId));\n\n            // Update per-beneficiary allocation and check cap\n            totalAllocatedOf[beneficiary] += amount;\n            uint256 totalAllocated = totalAllocatedOf[beneficiary];\n            require(\n                totalAllocated <= maxPreMintPerAddress,\n                MaxPreMintPerAddressExceeded(totalAllocated, maxPreMintPerAddress)\n            );\n\n            // Update vesting data and exclude from balance limit\n            vestingOf[beneficiary][scheduleId].totalAmount += amount;\n            isExcludedFromBalanceLimit[beneficiary] = true;\n\n            // Track schedule IDs for this beneficiary\n            if (!_hasTransientSchedule(beneficiary, scheduleId)) {\n                _setTransientSchedule(beneficiary, scheduleId);\n                _scheduleIdsOf[beneficiary].push(scheduleId);\n            }\n\n            vestedTokens += amount;\n            emit VestingAllocated(beneficiary, scheduleId, amount);\n        }\n\n        // Enforce total premint cap\n        require(vestedTokens <= maxTotalPreMint, MaxTotalPreMintExceeded(vestedTokens, maxTotalPreMint));\n        require(vestedTokens <= initialSupply, MaxTotalVestedExceeded(vestedTokens, initialSupply));\n\n        vestedTotalAmount = vestedTokens;\n\n        // Mint tokens\n        if (vestedTokens > 0) {\n            _mint(address(this), vestedTokens);\n        }\n        _mint(recipient, initialSupply - vestedTokens);\n    }\n\n    /* ----------------------------------------------------------------------- */\n    /*                                Pool Lock                                */\n    /* ----------------------------------------------------------------------- */\n\n    /**\n     * @notice Locks the pool, preventing it from receiving tokens, and excludes it from the balance limit\n     * @param pool_ Address of the pool to lock\n     */\n    function lockPool(address pool_) external onlyOwner {\n        require(!isPoolLocked, PoolAlreadyLocked());\n        pool = pool_;\n        isPoolLocked = true;\n        isExcludedFromBalanceLimit[pool_] = true;\n    }\n\n    /// @notice Unlocks the pool, allowing it to receive tokens\n    function unlockPool() external onlyOwner {\n        require(isPoolLocked, PoolAlreadyUnlocked());\n        isPoolLocked = false;\n    }\n\n    /* ------------------------------------------------------------------------- */\n    /*                                 Controller                                */\n    /* ------------------------------------------------------------------------- */\n\n    /// @notice Permanently disables the balance limit\n    /// @dev Only callable by the controller, which is set during initialization\n    ///      If the controller was not set, the balance limit cannot be disabled early\n    function disableBalanceLimit() external onlyController {\n        require(isBalanceLimitActive, BalanceLimitNotActive());\n        isBalanceLimitActive = false;\n        emit BalanceLimitDisabled(false);\n    }\n\n    /* ---------------------------------------------------------------------------- */\n    /*                                    Burn                                      */\n    /* ---------------------------------------------------------------------------- */\n\n    /**\n     * @notice Burns `amount` of tokens from the caller's balance\n     * @param amount Amount of tokens to burn\n     */\n    function burn(uint256 amount) external {\n        _burn(msg.sender, amount);\n    }\n\n    /* ---------------------------------------------------------------------------- */\n    /*                                  Token URI                                   */\n    /* ---------------------------------------------------------------------------- */\n\n    /**\n     * @notice Updates the token Uniform Resource Identifier (URI)\n     * @param tokenURI_ New token Uniform Resource Identifier (URI)\n     */\n    function updateTokenURI(string memory tokenURI_) external onlyOwner {\n        tokenURI = tokenURI_;\n        emit UpdateTokenURI(tokenURI_);\n    }\n\n    /* ----------------------------------------------------------------------------- */\n    /*                                Vesting Release                                */\n    /* ----------------------------------------------------------------------------- */\n\n    /**\n     * @notice Releases available vested tokens for a specific schedule\n     * @dev Use 0 for `amount` to release total available amount\n     * @param scheduleId Schedule ID to release from\n     * @param amount Amount of tokens to release\n     */\n    function release(uint256 scheduleId, uint256 amount) external {\n        _releaseFor(msg.sender, scheduleId, amount);\n    }\n\n    /**\n     * @notice Releases all available vested tokens across all schedules for the caller\n     * @dev Use 0 for `amount` to release total available amount\n     * @param amount Amount of tokens to release\n     */\n    function release(uint256 amount) external {\n        _releaseAllFor(msg.sender, amount);\n    }\n\n    /**\n     * @notice Releases available vested tokens for a beneficiary under a specific schedule\n     * @dev Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount\n     * @param beneficiary Bneficiary address\n     * @param scheduleId Schedule ID to release from\n     * @param amount Amount of tokens to release\n     */\n    function releaseFor(address beneficiary, uint256 scheduleId, uint256 amount) external {\n        _releaseFor(beneficiary, scheduleId, amount);\n    }\n\n    /**\n     * @notice Releases all available vested tokens for a beneficiary across all schedules\n     * @dev Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount\n     * @param beneficiary Beneficiary address\n     * @param amount Amount of tokens to release\n     */\n    function releaseFor(address beneficiary, uint256 amount) external {\n        _releaseAllFor(beneficiary, amount);\n    }\n\n    /* --------------------------------------------------------------------- */\n    /*                                Getters                                */\n    /* --------------------------------------------------------------------- */\n\n    /// @notice Returns the number of vesting schedules\n    function vestingScheduleCount() external view returns (uint256) {\n        return vestingSchedules.length;\n    }\n\n    /**\n     * @notice Returns the list of schedule IDs for a beneficiary\n     * @param beneficiary Beneficiary address\n     * @return Array of schedule IDs\n     */\n    function getScheduleIdsOf(address beneficiary) external view returns (uint256[] memory) {\n        return _scheduleIdsOf[beneficiary];\n    }\n\n    /**\n     * @notice Computes the available vested amount for a beneficiary under a specific schedule\n     * @param beneficiary Beneficiary address\n     * @param scheduleId Schedule ID\n     * @return Amount available to release\n     */\n    function computeAvailableVestedAmount(address beneficiary, uint256 scheduleId) public view returns (uint256) {\n        return _available(beneficiary, scheduleId);\n    }\n\n    /**\n     * @notice Computes the total available vested amount for a beneficiary across all schedules\n     * @param beneficiary Beneficiary address\n     * @return total Total amount available to release\n     */\n    function computeAvailableVestedAmount(address beneficiary) public view returns (uint256 total) {\n        uint256[] memory ids = _scheduleIdsOf[beneficiary];\n        uint256 length = ids.length;\n        for (uint256 i; i < length; i++) {\n            total += _available(beneficiary, ids[i]);\n        }\n    }\n\n    /* ----------------------------------------------------------------------- */\n    /*                                Internals                                */\n    /* ----------------------------------------------------------------------- */\n\n    /**\n     * @dev Computes the available (releasable) amount for a beneficiary under a schedule\n     * @param beneficiary Beneficiary address\n     * @param scheduleId Schedule ID\n     * @return Amount available to release\n     */\n    function _available(address beneficiary, uint256 scheduleId) internal view returns (uint256) {\n        VestingData storage vd = vestingOf[beneficiary][scheduleId];\n        uint256 totalAmount = vd.totalAmount;\n        if (totalAmount == 0) return 0;\n\n        VestingSchedule memory s = vestingSchedules[scheduleId];\n        uint256 t = block.timestamp;\n        uint256 start = vestingStart;\n\n        // Cliff gating: nothing claimable before cliff\n        if (t < start + s.cliff) return 0;\n\n        // Linear vesting from start\n        uint256 vested;\n        if (t >= start + s.duration) {\n            vested = totalAmount;\n        } else {\n            vested = (totalAmount * (t - start)) / s.duration;\n        }\n\n        uint256 released = vd.releasedAmount;\n        return vested > released ? vested - released : 0;\n    }\n\n    function _hasTransientSchedule(address beneficiary, uint256 scheduleId) internal view returns (bool) {\n        return LibTransient.get(LibTransient.tBool(_transientScheduleSlot(beneficiary, scheduleId)));\n    }\n\n    function _setTransientSchedule(address beneficiary, uint256 scheduleId) internal {\n        LibTransient.set(LibTransient.tBool(_transientScheduleSlot(beneficiary, scheduleId)), true);\n    }\n\n    function _transientScheduleSlot(address beneficiary, uint256 scheduleId) internal pure returns (bytes32) {\n        return keccak256(abi.encode(HAS_SCHEDULE_TRANSIENT_SLOT, beneficiary, scheduleId));\n    }\n\n    /**\n     * @dev Releases tokens for a beneficiary from a specific schedule\n     * @param beneficiary Beneficiary address\n     * @param scheduleId Schedule ID\n     * @param amount Amount of tokens to release\n     */\n    function _releaseFor(address beneficiary, uint256 scheduleId, uint256 amount) internal {\n        require(scheduleId < vestingSchedules.length, UnknownScheduleId(scheduleId));\n\n        uint256 available = _available(beneficiary, scheduleId);\n        require(available > 0, NoReleasableAmount());\n        if (amount > 0) require(available >= amount, InsufficientReleasableAmount(available, amount));\n        else amount = available;\n\n        vestingOf[beneficiary][scheduleId].releasedAmount += amount;\n        _transfer(address(this), beneficiary, amount);\n        emit TokensReleased(beneficiary, scheduleId, amount);\n    }\n\n    /**\n     * @dev Releases tokens for a beneficiary across all their schedules\n     * @param beneficiary Beneficiary address\n     * @param amount Amount of tokens to release\n     */\n    function _releaseAllFor(address beneficiary, uint256 amount) internal {\n        uint256[] memory ids = _scheduleIdsOf[beneficiary];\n        uint256 length = ids.length;\n\n        // First pass: compute available amounts and total, stop if non-zero amount is reached\n        uint256[] memory amounts = new uint256[](length);\n        uint256 total;\n        for (uint256 i; i < length; i++) {\n            amounts[i] = _available(beneficiary, ids[i]);\n            total += amounts[i];\n            if (amount > 0 && total >= amount) {\n                total = amount;\n                break;\n            }\n        }\n\n        // Ensure a requested amount is available\n        require(total >= amount, InsufficientReleasableAmount(total, amount));\n        amount = total;\n\n        // Ensure a non-zero amount is available\n        require(amount > 0, NoReleasableAmount());\n\n        // Second pass: update state and emit events\n        for (uint256 i; i < length; i++) {\n            if (amounts[i] > 0) {\n                uint256 released = amounts[i] > total ? total : amounts[i];\n                unchecked {\n                    vestingOf[beneficiary][ids[i]].releasedAmount += released;\n                    total -= released;\n                }\n\n                emit TokensReleased(beneficiary, ids[i], released);\n                if (total == 0) break;\n            }\n        }\n\n        // Single transfer\n        _transfer(address(this), beneficiary, amount);\n    }\n\n    /* ----------------------------------------------------------------------- */\n    /*                                Overrides                                */\n    /* ----------------------------------------------------------------------- */\n\n    /// @inheritdoc ERC20\n    function name() public view override returns (string memory) {\n        return _name;\n    }\n\n    /// @inheritdoc ERC20\n    function symbol() public view override returns (string memory) {\n        return _symbol;\n    }\n\n    /// @inheritdoc ERC20\n    function _beforeTokenTransfer(address from, address to, uint256 value) internal override {\n        if (to == pool && isPoolLocked) revert PoolLocked();\n        if (isBalanceLimitActive) {\n            // Exclude self transfers, burns, and vesting mints prior to checking exclusions\n            if (from != to && to != address(0) && to != address(this)) {\n                if (!isExcludedFromBalanceLimit[to]) {\n                    if (block.timestamp < balanceLimitEnd) {\n                        uint256 newBalance = balanceOf(to) + value;\n                        require(newBalance <= maxBalanceLimit, BalanceLimitExceeded(newBalance, maxBalanceLimit));\n                    } else {\n                        // Lazily disable balance limit on first post expiration transfer\n                        isBalanceLimitActive = false;\n                        emit BalanceLimitDisabled(true);\n                    }\n                }\n            }\n        }\n    }\n\n    /// @inheritdoc ERC20\n    function _givePermit2InfiniteAllowance() internal pure override returns (bool) {\n        return true;\n    }\n\n    /// @inheritdoc ERC20Votes\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal override(ERC20Votes, ERC20) {\n        super._afterTokenTransfer(from, to, amount);\n    }\n\n    /// @inheritdoc Ownable\n    function _setOwner(address newOwner) internal override {\n        // Exclude new owners from balance limit to prevent inflation mints from reverting\n        // This is only relevant if the balance limit is still enabled during/after migration\n        if (balanceLimitEnd > block.timestamp) isExcludedFromBalanceLimit[newOwner] = true;\n        super._setOwner(newOwner);\n    }\n}\n"},"src/types/Wad.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\n/// @dev Constant used to increase precision during calculations\nuint256 constant WAD = 1e18;\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.26+commit.8a97fa7a","compilerSettings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":0,"enabled":true},"evmVersion":"cancun","remappings":["ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/","forge-gas-snapshot/=lib/v4-core/lib/forge-gas-snapshot/src/","forge-std/=lib/forge-std/src/","hardhat/=lib/v4-core/node_modules/hardhat/","permit2/=lib/v4-periphery/lib/permit2/","@solmate/=lib/v4-core/lib/solmate/src/","@solady/=lib/solady/src/","@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/contracts/","lib/v4-core/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","lib/v4-periphery/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","lib/universal-router/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","@v4-periphery/=lib/v4-periphery/src/","@v4-periphery-test/=lib/v4-periphery/test/","@v4-core-test/=lib/v4-periphery/lib/v4-core/test/","@v4-core/=lib/v4-periphery/lib/v4-core/src/","@v3-periphery/=lib/v3-periphery/contracts/","@v3-core/=lib/v3-core/contracts/","@uniswap/v3-core/=lib/v3-core/","@universal-router/=lib/universal-router/contracts/","@uniswap/v2-core/contracts/interfaces/=src/interfaces/","@quoter/=lib/view-quoter-v4/src/","lib/v4-core/libraries/=lib/v4-periphery/lib/v4-core/libraries/","lib/v4-core/src/=lib/v4-periphery/lib/v4-core/src/","lib/view-quoter-v4/:@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/","@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/","createx/=lib/createx/src/","@ensdomains/=lib/v4-core/node_modules/@ensdomains/","@uniswap/v3-periphery/=lib/universal-router/lib/v3-periphery/","@uniswap/v4-periphery/=lib/universal-router/lib/v4-periphery/","dn404/=lib/dn404/","openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/","openzeppelin/=lib/createx/lib/openzeppelin-contracts/contracts/","solady/=lib/solady/src/","solmate/=lib/universal-router/lib/solmate/","universal-router/=lib/universal-router/","v3-core/=lib/v3-core/","v3-periphery/=lib/v3-periphery/contracts/","v4-core/=lib/v4-core/src/","v4-periphery/=lib/v4-periphery/","view-quoter-v4/=lib/view-quoter-v4/src/"]},"name":"DopplerERC20V1","fullyQualifiedName":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AllowanceOverflow","type":"error","inputs":[]},{"name":"AllowanceUnderflow","type":"error","inputs":[]},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"ArrayLengthsMismatch","type":"error","inputs":[]},{"name":"BalanceLimitExceeded","type":"error","inputs":[{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"BalanceLimitNotActive","type":"error","inputs":[]},{"name":"ERC5805CheckpointIndexOutOfBounds","type":"error","inputs":[]},{"name":"ERC5805CheckpointValueOverflow","type":"error","inputs":[]},{"name":"ERC5805CheckpointValueUnderflow","type":"error","inputs":[]},{"name":"ERC5805DelegateInvalidSignature","type":"error","inputs":[]},{"name":"ERC5805DelegateSignatureExpired","type":"error","inputs":[]},{"name":"ERC5805FutureLookup","type":"error","inputs":[]},{"name":"InsufficientAllowance","type":"error","inputs":[]},{"name":"InsufficientBalance","type":"error","inputs":[]},{"name":"InsufficientReleasableAmount","type":"error","inputs":[{"name":"available","type":"uint256","internalType":"uint256"},{"name":"requested","type":"uint256","internalType":"uint256"}]},{"name":"InvalidAllocation","type":"error","inputs":[{"name":"index","type":"uint256","internalType":"uint256"}]},{"name":"InvalidBalanceLimit","type":"error","inputs":[{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"InvalidBalanceLimitTimestamp","type":"error","inputs":[{"name":"specified","type":"uint256","internalType":"uint256"},{"name":"current","type":"uint256","internalType":"uint256"}]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"InvalidPermit","type":"error","inputs":[]},{"name":"InvalidSchedule","type":"error","inputs":[{"name":"scheduleId","type":"uint256","internalType":"uint256"}]},{"name":"MaxPreMintPerAddressExceeded","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"MaxTotalPreMintExceeded","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"MaxTotalVestedExceeded","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"NoReleasableAmount","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"Permit2AllowanceIsFixedAtInfinity","type":"error","inputs":[]},{"name":"PermitExpired","type":"error","inputs":[]},{"name":"PoolAlreadyLocked","type":"error","inputs":[]},{"name":"PoolAlreadyUnlocked","type":"error","inputs":[]},{"name":"PoolLocked","type":"error","inputs":[]},{"name":"TotalSupplyOverflow","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"UnknownScheduleId","type":"error","inputs":[{"name":"scheduleId","type":"uint256","internalType":"uint256"}]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"BalanceLimitDisabled","type":"event","inputs":[{"name":"expired","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"DelegateChanged","type":"event","inputs":[{"name":"delegator","type":"address","indexed":true,"internalType":"address"},{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"DelegateVotesChanged","type":"event","inputs":[{"name":"delegate","type":"address","indexed":true,"internalType":"address"},{"name":"oldValue","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newValue","type":"uint256","indexed":false,"internalType":"uint256"}],"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":"TokensReleased","type":"event","inputs":[{"name":"beneficiary","type":"address","indexed":true,"internalType":"address"},{"name":"scheduleId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"UpdateTokenURI","type":"event","inputs":[{"name":"tokenURI","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"VestingAllocated","type":"event","inputs":[{"name":"beneficiary","type":"address","indexed":true,"internalType":"address"},{"name":"scheduleId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"VestingScheduleCreated","type":"event","inputs":[{"name":"scheduleId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"cliff","type":"uint64","indexed":false,"internalType":"uint64"},{"name":"duration","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"CLOCK_MODE","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"result","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceLimitEnd","type":"function","inputs":[],"outputs":[{"name":"","type":"uint48","internalType":"uint48"}],"stateMutability":"view"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"burn","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"checkpointAt","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"i","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"checkpointClock","type":"uint48","internalType":"uint48"},{"name":"checkpointValue","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"checkpointCount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"clock","type":"function","inputs":[],"outputs":[{"name":"result","type":"uint48","internalType":"uint48"}],"stateMutability":"view"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"computeAvailableVestedAmount","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"},{"name":"scheduleId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"computeAvailableVestedAmount","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"}],"outputs":[{"name":"total","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"controller","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"delegate","type":"function","inputs":[{"name":"delegatee","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"delegateBySig","type":"function","inputs":[{"name":"delegatee","type":"address","internalType":"address"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"expiry","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"delegates","type":"function","inputs":[{"name":"delegator","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"disableBalanceLimit","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"getPastVotes","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"timepoint","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getPastVotesTotalSupply","type":"function","inputs":[{"name":"timepoint","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getScheduleIdsOf","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"view"},{"name":"getVotes","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getVotesTotalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"name_","type":"string","internalType":"string"},{"name":"symbol_","type":"string","internalType":"string"},{"name":"initialSupply","type":"uint256","internalType":"uint256"},{"name":"recipient","type":"address","internalType":"address"},{"name":"owner_","type":"address","internalType":"address"},{"name":"schedules","type":"tuple[]","components":[{"name":"cliff","type":"uint64","internalType":"uint64"},{"name":"duration","type":"uint64","internalType":"uint64"}],"internalType":"struct VestingSchedule[]"},{"name":"beneficiaries","type":"address[]","internalType":"address[]"},{"name":"scheduleIds","type":"uint256[]","internalType":"uint256[]"},{"name":"amounts","type":"uint256[]","internalType":"uint256[]"},{"name":"tokenURI_","type":"string","internalType":"string"},{"name":"maxBalanceLimit_","type":"uint256","internalType":"uint256"},{"name":"balanceLimitEnd_","type":"uint48","internalType":"uint48"},{"name":"controller_","type":"address","internalType":"address"},{"name":"excludedFromBalanceLimit","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isBalanceLimitActive","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isExcludedFromBalanceLimit","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"excluded","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isPoolLocked","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"lockPool","type":"function","inputs":[{"name":"pool_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"maxBalanceLimit","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"nonces","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"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":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"pool","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"release","type":"function","inputs":[{"name":"scheduleId","type":"uint256","internalType":"uint256"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"release","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"releaseFor","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"releaseFor","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"},{"name":"scheduleId","type":"uint256","internalType":"uint256"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalAllocatedOf","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"unlockPool","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateTokenURI","type":"function","inputs":[{"name":"tokenURI_","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"vestedTotalAmount","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"vestingOf","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"},{"name":"scheduleId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"totalAmount","type":"uint256","internalType":"uint256"},{"name":"releasedAmount","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"vestingScheduleCount","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"vestingSchedules","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"cliff","type":"uint64","internalType":"uint64"},{"name":"duration","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"name":"vestingStart","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.26+commit.8a97fa7a"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AllowanceOverflow","type":"error"},{"inputs":[],"name":"AllowanceUnderflow","type":"error"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"ArrayLengthsMismatch","type":"error"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"BalanceLimitExceeded","type":"error"},{"inputs":[],"name":"BalanceLimitNotActive","type":"error"},{"inputs":[],"name":"ERC5805CheckpointIndexOutOfBounds","type":"error"},{"inputs":[],"name":"ERC5805CheckpointValueOverflow","type":"error"},{"inputs":[],"name":"ERC5805CheckpointValueUnderflow","type":"error"},{"inputs":[],"name":"ERC5805DelegateInvalidSignature","type":"error"},{"inputs":[],"name":"ERC5805DelegateSignatureExpired","type":"error"},{"inputs":[],"name":"ERC5805FutureLookup","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"uint256","name":"available","type":"uint256"},{"internalType":"uint256","name":"requested","type":"uint256"}],"name":"InsufficientReleasableAmount","type":"error"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"InvalidAllocation","type":"error"},{"inputs":[{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"InvalidBalanceLimit","type":"error"},{"inputs":[{"internalType":"uint256","name":"specified","type":"uint256"},{"internalType":"uint256","name":"current","type":"uint256"}],"name":"InvalidBalanceLimitTimestamp","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidPermit","type":"error"},{"inputs":[{"internalType":"uint256","name":"scheduleId","type":"uint256"}],"name":"InvalidSchedule","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"MaxPreMintPerAddressExceeded","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"MaxTotalPreMintExceeded","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"MaxTotalVestedExceeded","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"NoReleasableAmount","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"Permit2AllowanceIsFixedAtInfinity","type":"error"},{"inputs":[],"name":"PermitExpired","type":"error"},{"inputs":[],"name":"PoolAlreadyLocked","type":"error"},{"inputs":[],"name":"PoolAlreadyUnlocked","type":"error"},{"inputs":[],"name":"PoolLocked","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[{"internalType":"uint256","name":"scheduleId","type":"uint256"}],"name":"UnknownScheduleId","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"expired","type":"bool"}],"name":"BalanceLimitDisabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldValue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"DelegateVotesChanged","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":"beneficiary","type":"address"},{"indexed":true,"internalType":"uint256","name":"scheduleId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"tokenURI","type":"string"}],"name":"UpdateTokenURI","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":true,"internalType":"uint256","name":"scheduleId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"VestingAllocated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"scheduleId","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"cliff","type":"uint64"},{"indexed":false,"internalType":"uint64","name":"duration","type":"uint64"}],"name":"VestingScheduleCreated","type":"event"},{"inputs":[],"name":"CLOCK_MODE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"result","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"balanceLimitEnd","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"i","type":"uint256"}],"name":"checkpointAt","outputs":[{"internalType":"uint48","name":"checkpointClock","type":"uint48"},{"internalType":"uint256","name":"checkpointValue","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"checkpointCount","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clock","outputs":[{"internalType":"uint48","name":"result","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"scheduleId","type":"uint256"}],"name":"computeAvailableVestedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"computeAvailableVestedAmount","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"disableBalanceLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastVotesTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"getScheduleIdsOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVotesTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint256","name":"initialSupply","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"owner_","type":"address"},{"components":[{"internalType":"uint64","name":"cliff","type":"uint64"},{"internalType":"uint64","name":"duration","type":"uint64"}],"internalType":"struct VestingSchedule[]","name":"schedules","type":"tuple[]"},{"internalType":"address[]","name":"beneficiaries","type":"address[]"},{"internalType":"uint256[]","name":"scheduleIds","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"string","name":"tokenURI_","type":"string"},{"internalType":"uint256","name":"maxBalanceLimit_","type":"uint256"},{"internalType":"uint48","name":"balanceLimitEnd_","type":"uint48"},{"internalType":"address","name":"controller_","type":"address"},{"internalType":"address[]","name":"excludedFromBalanceLimit","type":"address[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isBalanceLimitActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromBalanceLimit","outputs":[{"internalType":"bool","name":"excluded","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPoolLocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool_","type":"address"}],"name":"lockPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxBalanceLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"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":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"scheduleId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"releaseFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"scheduleId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"releaseFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"totalAllocatedOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"unlockPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"tokenURI_","type":"string"}],"name":"updateTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vestedTotalAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"scheduleId","type":"uint256"}],"name":"vestingOf","outputs":[{"internalType":"uint256","name":"totalAmount","type":"uint256"},{"internalType":"uint256","name":"releasedAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingScheduleCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"vestingSchedules","outputs":[{"internalType":"uint64","name":"cliff","type":"uint64"},{"internalType":"uint64","name":"duration","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],"devdoc":{"author":"Whetstone Research","custom:security-contact":"security@whetstone.cc","details":"This contract is designed to be cloned using the ERC1167 minimal proxy pattern","errors":{"AllowanceOverflow()":[{"details":"The allowance has overflowed."}],"AllowanceUnderflow()":[{"details":"The allowance has underflowed."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"ArrayLengthsMismatch()":[{"details":"Thrown when two arrays have different lengths"}],"BalanceLimitExceeded(uint256,uint256)":[{"details":"Thrown when an address's balance exceeds the balance limit"}],"BalanceLimitNotActive()":[{"details":"Thrown when the balance limit is not active"}],"ERC5805CheckpointIndexOutOfBounds()":[{"details":"Out-of-bounds access for the checkpoints."}],"ERC5805CheckpointValueOverflow()":[{"details":"Arithmetic overflow when pushing a new checkpoint."}],"ERC5805CheckpointValueUnderflow()":[{"details":"Arithmetic underflow when pushing a new checkpoint."}],"ERC5805DelegateInvalidSignature()":[{"details":"The ERC5805 signature to set a delegate is invalid."}],"ERC5805DelegateSignatureExpired()":[{"details":"The ERC5805 signature to set a delegate has expired."}],"ERC5805FutureLookup()":[{"details":"The timepoint is in the future."}],"InsufficientAllowance()":[{"details":"Insufficient allowance."}],"InsufficientBalance()":[{"details":"Insufficient balance."}],"InsufficientReleasableAmount(uint256,uint256)":[{"details":"Thrown when the requested amount is greater than the available amount"}],"InvalidAllocation(uint256)":[{"details":"Thrown when an allocation is invalid (zero address or zero amount)"}],"InvalidBalanceLimit(uint256)":[{"details":"Thrown when the specified balance limit wad is invalid"}],"InvalidBalanceLimitTimestamp(uint256,uint256)":[{"details":"Thrown when the specified balance limit timestamp is in the past"}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"InvalidPermit()":[{"details":"The permit is invalid."}],"InvalidSchedule(uint256)":[{"details":"Thrown when a schedule is invalid (violates duration/cliff constraints)"}],"MaxPreMintPerAddressExceeded(uint256,uint256)":[{"details":"Thrown when trying to premint more than the maximum allowed per address"}],"MaxTotalPreMintExceeded(uint256,uint256)":[{"details":"Thrown when trying to premint more than the maximum allowed in total"}],"MaxTotalVestedExceeded(uint256,uint256)":[{"details":"Thrown when trying to mint more than the maximum allowed in total"}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"NoReleasableAmount()":[{"details":"Thrown when there is no releasable amount"}],"NotInitializing()":[{"details":"The contract is not initializing."}],"Permit2AllowanceIsFixedAtInfinity()":[{"details":"The allowance of Permit2 is fixed at infinity."}],"PermitExpired()":[{"details":"The permit has expired."}],"PoolAlreadyLocked()":[{"details":"Thrown when trying to lock the pool while it is already locked"}],"PoolAlreadyUnlocked()":[{"details":"Thrown when trying to unlock the pool while it is already unlocked"}],"PoolLocked()":[{"details":"Thrown when trying to transfer tokens into the pool while it is locked"}],"TotalSupplyOverflow()":[{"details":"The total supply has overflowed."}],"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"UnknownScheduleId(uint256)":[{"details":"Thrown when the schedule ID is out of range"}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when `amount` tokens is approved by `owner` to be used by `spender`."},"DelegateChanged(address,address,address)":{"details":"The delegate of `delegator` is changed from `from` to `to`."},"DelegateVotesChanged(address,uint256,uint256)":{"details":"The votes balance of `delegate` is changed from `oldValue` to `newValue`."},"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."},"Transfer(address,address,uint256)":{"details":"Emitted when `amount` tokens is transferred from `from` to `to`."}},"kind":"dev","methods":{"CLOCK_MODE()":{"details":"Returns the clock mode."},"DOMAIN_SEPARATOR()":{"details":"Returns the EIP-712 domain separator for the EIP-2612 permit."},"allowance(address,address)":{"details":"Returns the amount of tokens that `spender` can spend on behalf of `owner`."},"approve(address,uint256)":{"details":"Sets `amount` as the allowance of `spender` over the caller's tokens. Emits a {Approval} event."},"balanceOf(address)":{"details":"Returns the amount of tokens owned by `owner`."},"burn(uint256)":{"params":{"amount":"Amount of tokens to burn"}},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"checkpointAt(address,uint256)":{"details":"Returns the voting checkpoint for `account` at index `i`."},"checkpointCount(address)":{"details":"Returns the number of checkpoints for `account`."},"clock()":{"details":"Retusn the current clock."},"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`."},"computeAvailableVestedAmount(address)":{"params":{"beneficiary":"Beneficiary address"},"returns":{"total":"Total amount available to release"}},"computeAvailableVestedAmount(address,uint256)":{"params":{"beneficiary":"Beneficiary address","scheduleId":"Schedule ID"},"returns":{"_0":"Amount available to release"}},"decimals()":{"details":"Returns the decimals places of the token."},"delegate(address)":{"details":"Set the voting delegate of the caller to `delegatee`."},"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets the voting delegate of the signature signer to `delegatee`."},"delegates(address)":{"details":"Returns the current voting delegate of `delegator`."},"disableBalanceLimit()":{"details":"Only callable by the controller, which is set during initialization      If the controller was not set, the balance limit cannot be disabled early"},"getPastVotes(address,uint256)":{"details":"Returns the latest amount of voting units `account` has before `timepoint`."},"getPastVotesTotalSupply(uint256)":{"details":"Returns the latest amount of total voting units before `timepoint`."},"getScheduleIdsOf(address)":{"params":{"beneficiary":"Beneficiary address"},"returns":{"_0":"Array of schedule IDs"}},"getVotes(address)":{"details":"Returns the latest amount of voting units for `account`."},"getVotesTotalSupply()":{"details":"Returns the latest amount of total voting units."},"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])":{"params":{"amounts":"Array of amounts for each allocation","balanceLimitEnd_":"Balance limit end timestamp","beneficiaries":"Array of beneficiary addresses for allocations","controller_":"Controller address (optional, excluding it prevents disabling the balance limit earlier)","excludedFromBalanceLimit":"Array of addresses to exclude from the balance limit.                                 This should include initializers, migrators, Uniswap PoolManager, treasury, etc.","initialSupply":"Initial supply of the token","maxBalanceLimit_":"Maximum balance limit","name_":"Name of the token","owner_":"Address receiving the ownership of the token","recipient":"Address receiving the non-vested initial supply","scheduleIds":"Array of schedule IDs corresponding to each allocation","schedules":"Array of vesting schedules","symbol_":"Symbol of the token","tokenURI_":"Uniform Resource Identifier (URI)"}},"lockPool(address)":{"params":{"pool_":"Address of the pool to lock"}},"name()":{"details":"Returns the name of the token."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value is used to compute the signature for EIP-2612 permit."},"owner()":{"details":"Returns the owner of the contract."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets `value` as the allowance of `spender` over the tokens of `owner`, authorized by a signed approval by `owner`. Emits a {Approval} event."},"release(uint256)":{"details":"Use 0 for `amount` to release total available amount","params":{"amount":"Amount of tokens to release"}},"release(uint256,uint256)":{"details":"Use 0 for `amount` to release total available amount","params":{"amount":"Amount of tokens to release","scheduleId":"Schedule ID to release from"}},"releaseFor(address,uint256)":{"details":"Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount","params":{"amount":"Amount of tokens to release","beneficiary":"Beneficiary address"}},"releaseFor(address,uint256,uint256)":{"details":"Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount","params":{"amount":"Amount of tokens to release","beneficiary":"Bneficiary address","scheduleId":"Schedule ID to release from"}},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"symbol()":{"details":"Returns the symbol of the token."},"totalSupply()":{"details":"Returns the amount of tokens in existence."},"transfer(address,uint256)":{"details":"Transfer `amount` tokens from the caller to `to`. Requirements: - `from` must at least have `amount`. Emits a {Transfer} event."},"transferFrom(address,address,uint256)":{"details":"Transfers `amount` tokens from `from` to `to`. Note: Does not update the allowance if it is the maximum uint256 value. Requirements: - `from` must at least have `amount`. - The caller must have at least `amount` of allowance to transfer the tokens of `from`. Emits a {Transfer} event."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"updateTokenURI(string)":{"params":{"tokenURI_":"New token Uniform Resource Identifier (URI)"}}},"stateVariables":{"_name":{"details":"Name of the token"},"_symbol":{"details":"Symbol of the token"}},"title":"DopplerERC20 V1.0.0","version":1},"userdoc":{"events":{"BalanceLimitDisabled(bool)":{"notice":"Emitted when the balance limit is disabled"},"TokensReleased(address,uint256,uint256)":{"notice":"Emitted when tokens are released to a beneficiary"},"UpdateTokenURI(string)":{"notice":"Emitted when the token URI is updated"},"VestingAllocated(address,uint256,uint256)":{"notice":"Emitted when tokens are allocated to a beneficiary under a schedule"},"VestingScheduleCreated(uint256,uint64,uint64)":{"notice":"Emitted when a new vesting schedule is created"}},"kind":"user","methods":{"balanceLimitEnd()":{"notice":"Balance limit end timestamp (in seconds)"},"burn(uint256)":{"notice":"Burns `amount` of tokens from the caller's balance"},"computeAvailableVestedAmount(address)":{"notice":"Computes the total available vested amount for a beneficiary across all schedules"},"computeAvailableVestedAmount(address,uint256)":{"notice":"Computes the available vested amount for a beneficiary under a specific schedule"},"controller()":{"notice":"Controller address (can disable the balance limit)"},"disableBalanceLimit()":{"notice":"Permanently disables the balance limit"},"getScheduleIdsOf(address)":{"notice":"Returns the list of schedule IDs for a beneficiary"},"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])":{"notice":"Initializes the token with the given parameters"},"isBalanceLimitActive()":{"notice":"Whether the balance limit is active or not"},"isExcludedFromBalanceLimit(address)":{"notice":"Whether an address is excluded from the balance limit"},"isPoolLocked()":{"notice":"Whether the pool can receive tokens (unlocked) or not"},"lockPool(address)":{"notice":"Locks the pool, preventing it from receiving tokens, and excludes it from the balance limit"},"maxBalanceLimit()":{"notice":"Maximum balance limit"},"pool()":{"notice":"Address of the liquidity pool"},"release(uint256)":{"notice":"Releases all available vested tokens across all schedules for the caller"},"release(uint256,uint256)":{"notice":"Releases available vested tokens for a specific schedule"},"releaseFor(address,uint256)":{"notice":"Releases all available vested tokens for a beneficiary across all schedules"},"releaseFor(address,uint256,uint256)":{"notice":"Releases available vested tokens for a beneficiary under a specific schedule"},"tokenURI()":{"notice":"Uniform Resource Identifier (URI)"},"totalAllocatedOf(address)":{"notice":"Total allocated amount per beneficiary (for cap enforcement)"},"unlockPool()":{"notice":"Unlocks the pool, allowing it to receive tokens"},"updateTokenURI(string)":{"notice":"Updates the token Uniform Resource Identifier (URI)"},"vestedTotalAmount()":{"notice":"Total amount of vested tokens across all beneficiaries and schedules"},"vestingOf(address,uint256)":{"notice":"Vesting data for each (beneficiary, scheduleId) pair"},"vestingScheduleCount()":{"notice":"Returns the number of vesting schedules"},"vestingSchedules(uint256)":{"notice":"Array of vesting schedules (scheduleId = index)"},"vestingStart()":{"notice":"Timestamp of the start of all vesting schedules"}},"notice":"Clonable ERC20 token with multi-schedule vesting, pool lock, votes, max balance limit, and Permit2 support","version":1}},"settings":{"compilationTarget":{"src/tokens/DopplerERC20V1.sol":"DopplerERC20V1"},"evmVersion":"cancun","libraries":{},"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":0},"remappings":[":@ensdomains/=lib/v4-core/node_modules/@ensdomains/",":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/contracts/",":@quoter/=lib/view-quoter-v4/src/",":@solady/=lib/solady/src/",":@solmate/=lib/v4-core/lib/solmate/src/",":@uniswap/v2-core/contracts/interfaces/=src/interfaces/",":@uniswap/v3-core/=lib/v3-core/",":@uniswap/v3-periphery/=lib/universal-router/lib/v3-periphery/",":@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/",":@uniswap/v4-periphery/=lib/universal-router/lib/v4-periphery/",":@universal-router/=lib/universal-router/contracts/",":@v3-core/=lib/v3-core/contracts/",":@v3-periphery/=lib/v3-periphery/contracts/",":@v4-core-test/=lib/v4-periphery/lib/v4-core/test/",":@v4-core/=lib/v4-periphery/lib/v4-core/src/",":@v4-periphery-test/=lib/v4-periphery/test/",":@v4-periphery/=lib/v4-periphery/src/",":createx/=lib/createx/src/",":dn404/=lib/dn404/",":ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-gas-snapshot/=lib/v4-core/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":hardhat/=lib/v4-core/node_modules/hardhat/",":lib/v4-core/libraries/=lib/v4-periphery/lib/v4-core/libraries/",":lib/v4-core/src/=lib/v4-periphery/lib/v4-core/src/",":openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/",":openzeppelin/=lib/createx/lib/openzeppelin-contracts/contracts/",":permit2/=lib/v4-periphery/lib/permit2/",":solady/=lib/solady/src/",":solmate/=lib/universal-router/lib/solmate/",":universal-router/=lib/universal-router/",":v3-core/=lib/v3-core/",":v3-periphery/=lib/v3-periphery/contracts/",":v4-core/=lib/v4-core/src/",":v4-periphery/=lib/v4-periphery/",":view-quoter-v4/=lib/view-quoter-v4/src/","lib/universal-router/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","lib/v4-core/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","lib/v4-periphery/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","lib/view-quoter-v4/:@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/"],"viaIR":true},"sources":{"lib/solady/src/auth/Ownable.sol":{"keccak256":"0xc208cdd9de02bbf4b5edad18b88e23a2be7ff56d2287d5649329dc7cda64b9a3","license":"MIT","urls":["bzz-raw://e8fba079cc7230c617f7493a2e97873f88e59a53a5018fcb2e2b6ac42d8aa5a3","dweb:/ipfs/QmTXg8GSt8hsK2cZhbPFrund1mrwVdkLQmEPoQaFy4fhjs"]},"lib/solady/src/tokens/ERC20.sol":{"keccak256":"0x1c3cdf5158b29b16ba2d2c7ff1f6d4304754605441257e198b46803f0fa9df1a","license":"MIT","urls":["bzz-raw://f6ed3d15fd372495ff76439878fb5e007ae0b39da3ce3d9fd877ee8147647bb2","dweb:/ipfs/QmZ1zC91VhPHMXAdcY8SahJMwDsC2B5q9uXFF16R5eHmkV"]},"lib/solady/src/tokens/ERC20Votes.sol":{"keccak256":"0x070ca968051573401964700c7c903d3106d46d8db1c33a394c20e2cf21e61306","license":"MIT","urls":["bzz-raw://5de163eb6cea2d453e80e93bb8b790ba5f45b554dcd16feb5825f0c8d4e1463d","dweb:/ipfs/QmcfbzZv7TniFTnnY8bxbLsGHRboJybbisK4zHiwkeXjBD"]},"lib/solady/src/utils/Initializable.sol":{"keccak256":"0x039ac865df50f874528619e58f2bfaa665b6cec82647c711e515cb252a45a2ec","license":"MIT","urls":["bzz-raw://1886c0e71f4861a23113f9d3eb5f6f00397c1d1bf0191f92534c177a79ac8559","dweb:/ipfs/QmPLWU427MN9KHFg6DFkrYNutCDLdtNSQLaqmPqKcoPRLy"]},"lib/solady/src/utils/LibTransient.sol":{"keccak256":"0xd88aaa025471524c7cc93b7cf45318963bdea2c2bcb7c6c4064a96d3d97c2b64","license":"MIT","urls":["bzz-raw://4891fab99ef22c149eb819492b245e4831497f8bd828171e892c284bd31921a9","dweb:/ipfs/QmdsxhTsdNHEJNDR2QZb5NDK4oc4yxPJX42rpdHrB51dcv"]},"src/tokens/DopplerERC20V1.sol":{"keccak256":"0xbbd682cb5e84acbd957b99aedd53f4ee2ea7fe617588649b53ba96475007310a","license":"BUSL-1.1","urls":["bzz-raw://5927ddcb9d51f61dff1076ddf5a207fcd1521353245bd7a98a502a581d24e7ed","dweb:/ipfs/QmPwfupkXDg9zjgy5oP52VtXiHtLMC9rUVbrBMdJHUNgwF"]},"src/types/Wad.sol":{"keccak256":"0xef31939439d4fab5c019df2ab74badcd0093b0f7662188e5ff36bf28e529dc65","license":"MIT","urls":["bzz-raw://1e81ea4d92568594c3bc8f8347a8264ee4b7bf4f517d0af89daf44a1e2166e32","dweb:/ipfs/QmUNjcUB27BEGhUypiq8mmMwQwkLKu6okXXhTBT66k6qHk"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint48":{"label":"uint48","encoding":"inplace","numberOfBytes":"6"},"t_uint64":{"label":"uint64","encoding":"inplace","numberOfBytes":"8"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_array(t_uint256)dyn_storage":{"base":"t_uint256","label":"uint256[]","encoding":"dynamic_array","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_struct(VestingData)2889_storage":{"label":"struct VestingData","members":[{"slot":"0","type":"t_uint256","astId":2886,"label":"totalAmount","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"1","type":"t_uint256","astId":2888,"label":"releasedAmount","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"}],"encoding":"inplace","numberOfBytes":"64"},"t_struct(VestingSchedule)2883_storage":{"label":"struct VestingSchedule","members":[{"slot":"0","type":"t_uint64","astId":2880,"label":"cliff","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"0","type":"t_uint64","astId":2882,"label":"duration","offset":8,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_array(t_uint256)dyn_storage)":{"key":"t_address","label":"mapping(address => uint256[])","value":"t_array(t_uint256)dyn_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_struct(VestingData)2889_storage)":{"key":"t_uint256","label":"mapping(uint256 => struct VestingData)","value":"t_struct(VestingData)2889_storage","encoding":"mapping","numberOfBytes":"32"},"t_array(t_struct(VestingSchedule)2883_storage)dyn_storage":{"base":"t_struct(VestingSchedule)2883_storage","label":"struct VestingSchedule[]","encoding":"dynamic_array","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_uint256,t_struct(VestingData)2889_storage))":{"key":"t_address","label":"mapping(address => mapping(uint256 => struct VestingData))","value":"t_mapping(t_uint256,t_struct(VestingData)2889_storage)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_string_storage","astId":2938,"label":"_name","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"1","type":"t_string_storage","astId":2941,"label":"_symbol","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"2","type":"t_string_storage","astId":2944,"label":"tokenURI","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"3","type":"t_uint256","astId":2947,"label":"vestingStart","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"4","type":"t_uint256","astId":2950,"label":"vestedTotalAmount","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"5","type":"t_address","astId":2953,"label":"controller","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"6","type":"t_address","astId":2956,"label":"pool","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"6","type":"t_bool","astId":2959,"label":"isPoolLocked","offset":20,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"6","type":"t_bool","astId":2962,"label":"isBalanceLimitActive","offset":21,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"6","type":"t_uint48","astId":2965,"label":"balanceLimitEnd","offset":22,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"7","type":"t_uint256","astId":2968,"label":"maxBalanceLimit","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"8","type":"t_array(t_struct(VestingSchedule)2883_storage)dyn_storage","astId":2973,"label":"vestingSchedules","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"9","type":"t_mapping(t_address,t_mapping(t_uint256,t_struct(VestingData)2889_storage))","astId":2981,"label":"vestingOf","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"10","type":"t_mapping(t_address,t_uint256)","astId":2986,"label":"totalAllocatedOf","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"11","type":"t_mapping(t_address,t_array(t_uint256)dyn_storage)","astId":2992,"label":"_scheduleIdsOf","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"12","type":"t_mapping(t_address,t_bool)","astId":2997,"label":"isExcludedFromBalanceLimit","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","events":{"UpdateTokenURI(string)":{"notice":"Emitted when the token URI is updated"},"BalanceLimitDisabled(bool)":{"notice":"Emitted when the balance limit is disabled"},"TokensReleased(address,uint256,uint256)":{"notice":"Emitted when tokens are released to a beneficiary"},"VestingAllocated(address,uint256,uint256)":{"notice":"Emitted when tokens are allocated to a beneficiary under a schedule"},"VestingScheduleCreated(uint256,uint64,uint64)":{"notice":"Emitted when a new vesting schedule is created"}},"notice":"Clonable ERC20 token with multi-schedule vesting, pool lock, votes, max balance limit, and Permit2 support","methods":{"pool()":{"notice":"Address of the liquidity pool"},"tokenURI()":{"notice":"Uniform Resource Identifier (URI)"},"controller()":{"notice":"Controller address (can disable the balance limit)"},"unlockPool()":{"notice":"Unlocks the pool, allowing it to receive tokens"},"burn(uint256)":{"notice":"Burns `amount` of tokens from the caller's balance"},"isPoolLocked()":{"notice":"Whether the pool can receive tokens (unlocked) or not"},"vestingStart()":{"notice":"Timestamp of the start of all vesting schedules"},"release(uint256)":{"notice":"Releases all available vested tokens across all schedules for the caller"},"balanceLimitEnd()":{"notice":"Balance limit end timestamp (in seconds)"},"lockPool(address)":{"notice":"Locks the pool, preventing it from receiving tokens, and excludes it from the balance limit"},"maxBalanceLimit()":{"notice":"Maximum balance limit"},"vestedTotalAmount()":{"notice":"Total amount of vested tokens across all beneficiaries and schedules"},"disableBalanceLimit()":{"notice":"Permanently disables the balance limit"},"isBalanceLimitActive()":{"notice":"Whether the balance limit is active or not"},"updateTokenURI(string)":{"notice":"Updates the token Uniform Resource Identifier (URI)"},"vestingScheduleCount()":{"notice":"Returns the number of vesting schedules"},"release(uint256,uint256)":{"notice":"Releases available vested tokens for a specific schedule"},"getScheduleIdsOf(address)":{"notice":"Returns the list of schedule IDs for a beneficiary"},"totalAllocatedOf(address)":{"notice":"Total allocated amount per beneficiary (for cap enforcement)"},"vestingSchedules(uint256)":{"notice":"Array of vesting schedules (scheduleId = index)"},"vestingOf(address,uint256)":{"notice":"Vesting data for each (beneficiary, scheduleId) pair"},"releaseFor(address,uint256)":{"notice":"Releases all available vested tokens for a beneficiary across all schedules"},"isExcludedFromBalanceLimit(address)":{"notice":"Whether an address is excluded from the balance limit"},"releaseFor(address,uint256,uint256)":{"notice":"Releases available vested tokens for a beneficiary under a specific schedule"},"computeAvailableVestedAmount(address)":{"notice":"Computes the total available vested amount for a beneficiary across all schedules"},"computeAvailableVestedAmount(address,uint256)":{"notice":"Computes the available vested amount for a beneficiary under a specific schedule"},"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])":{"notice":"Initializes the token with the given parameters"}},"version":1},"devdoc":{"kind":"dev","title":"DopplerERC20 V1.0.0","author":"Whetstone Research","errors":{"PoolLocked()":[{"details":"Thrown when trying to transfer tokens into the pool while it is locked"}],"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"InvalidPermit()":[{"details":"The permit is invalid."}],"PermitExpired()":[{"details":"The permit has expired."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"AllowanceOverflow()":[{"details":"The allowance has overflowed."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"PoolAlreadyLocked()":[{"details":"Thrown when trying to lock the pool while it is already locked"}],"AllowanceUnderflow()":[{"details":"The allowance has underflowed."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"NoReleasableAmount()":[{"details":"Thrown when there is no releasable amount"}],"ERC5805FutureLookup()":[{"details":"The timepoint is in the future."}],"InsufficientBalance()":[{"details":"Insufficient balance."}],"PoolAlreadyUnlocked()":[{"details":"Thrown when trying to unlock the pool while it is already unlocked"}],"TotalSupplyOverflow()":[{"details":"The total supply has overflowed."}],"ArrayLengthsMismatch()":[{"details":"Thrown when two arrays have different lengths"}],"BalanceLimitNotActive()":[{"details":"Thrown when the balance limit is not active"}],"InsufficientAllowance()":[{"details":"Insufficient allowance."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"InvalidSchedule(uint256)":[{"details":"Thrown when a schedule is invalid (violates duration/cliff constraints)"}],"InvalidAllocation(uint256)":[{"details":"Thrown when an allocation is invalid (zero address or zero amount)"}],"UnknownScheduleId(uint256)":[{"details":"Thrown when the schedule ID is out of range"}],"InvalidBalanceLimit(uint256)":[{"details":"Thrown when the specified balance limit wad is invalid"}],"ERC5805CheckpointValueOverflow()":[{"details":"Arithmetic overflow when pushing a new checkpoint."}],"ERC5805CheckpointValueUnderflow()":[{"details":"Arithmetic underflow when pushing a new checkpoint."}],"ERC5805DelegateInvalidSignature()":[{"details":"The ERC5805 signature to set a delegate is invalid."}],"ERC5805DelegateSignatureExpired()":[{"details":"The ERC5805 signature to set a delegate has expired."}],"ERC5805CheckpointIndexOutOfBounds()":[{"details":"Out-of-bounds access for the checkpoints."}],"Permit2AllowanceIsFixedAtInfinity()":[{"details":"The allowance of Permit2 is fixed at infinity."}],"BalanceLimitExceeded(uint256,uint256)":[{"details":"Thrown when an address's balance exceeds the balance limit"}],"MaxTotalVestedExceeded(uint256,uint256)":[{"details":"Thrown when trying to mint more than the maximum allowed in total"}],"MaxTotalPreMintExceeded(uint256,uint256)":[{"details":"Thrown when trying to premint more than the maximum allowed in total"}],"InsufficientReleasableAmount(uint256,uint256)":[{"details":"Thrown when the requested amount is greater than the available amount"}],"InvalidBalanceLimitTimestamp(uint256,uint256)":[{"details":"Thrown when the specified balance limit timestamp is in the past"}],"MaxPreMintPerAddressExceeded(uint256,uint256)":[{"details":"Thrown when trying to premint more than the maximum allowed per address"}]},"events":{"Initialized(uint64)":{"details":"Triggered when the contract has been initialized."},"Approval(address,address,uint256)":{"details":"Emitted when `amount` tokens is approved by `owner` to be used by `spender`."},"Transfer(address,address,uint256)":{"details":"Emitted when `amount` tokens is transferred from `from` to `to`."},"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."},"DelegateChanged(address,address,address)":{"details":"The delegate of `delegator` is changed from `from` to `to`."},"DelegateVotesChanged(address,uint256,uint256)":{"details":"The votes balance of `delegate` is changed from `oldValue` to `newValue`."}},"details":"This contract is designed to be cloned using the ERC1167 minimal proxy pattern","methods":{"name()":{"details":"Returns the name of the token."},"clock()":{"details":"Retusn the current clock."},"owner()":{"details":"Returns the owner of the contract."},"symbol()":{"details":"Returns the symbol of the token."},"decimals()":{"details":"Returns the decimals places of the token."},"CLOCK_MODE()":{"details":"Returns the clock mode."},"burn(uint256)":{"params":{"amount":"Amount of tokens to burn"}},"totalSupply()":{"details":"Returns the amount of tokens in existence."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value is used to compute the signature for EIP-2612 permit."},"release(uint256)":{"params":{"amount":"Amount of tokens to release"},"details":"Use 0 for `amount` to release total available amount"},"delegate(address)":{"details":"Set the voting delegate of the caller to `delegatee`."},"getVotes(address)":{"details":"Returns the latest amount of voting units for `account`."},"lockPool(address)":{"params":{"pool_":"Address of the pool to lock"}},"DOMAIN_SEPARATOR()":{"details":"Returns the EIP-712 domain separator for the EIP-2612 permit."},"balanceOf(address)":{"details":"Returns the amount of tokens owned by `owner`."},"delegates(address)":{"details":"Returns the current voting delegate of `delegator`."},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"disableBalanceLimit()":{"details":"Only callable by the controller, which is set during initialization      If the controller was not set, the balance limit cannot be disabled early"},"getVotesTotalSupply()":{"details":"Returns the latest amount of total voting units."},"updateTokenURI(string)":{"params":{"tokenURI_":"New token Uniform Resource Identifier (URI)"}},"approve(address,uint256)":{"details":"Sets `amount` as the allowance of `spender` over the caller's tokens. Emits a {Approval} event."},"checkpointCount(address)":{"details":"Returns the number of checkpoints for `account`."},"release(uint256,uint256)":{"params":{"amount":"Amount of tokens to release","scheduleId":"Schedule ID to release from"},"details":"Use 0 for `amount` to release total available amount"},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"getScheduleIdsOf(address)":{"params":{"beneficiary":"Beneficiary address"},"returns":{"_0":"Array of schedule IDs"}},"transfer(address,uint256)":{"details":"Transfer `amount` tokens from the caller to `to`. Requirements: - `from` must at least have `amount`. Emits a {Transfer} event."},"allowance(address,address)":{"details":"Returns the amount of tokens that `spender` can spend on behalf of `owner`."},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"releaseFor(address,uint256)":{"params":{"amount":"Amount of tokens to release","beneficiary":"Beneficiary address"},"details":"Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount"},"checkpointAt(address,uint256)":{"details":"Returns the voting checkpoint for `account` at index `i`."},"getPastVotes(address,uint256)":{"details":"Returns the latest amount of voting units `account` has before `timepoint`."},"getPastVotesTotalSupply(uint256)":{"details":"Returns the latest amount of total voting units before `timepoint`."},"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`."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"releaseFor(address,uint256,uint256)":{"params":{"amount":"Amount of tokens to release","scheduleId":"Schedule ID to release from","beneficiary":"Bneficiary address"},"details":"Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount"},"computeAvailableVestedAmount(address)":{"params":{"beneficiary":"Beneficiary address"},"returns":{"total":"Total amount available to release"}},"transferFrom(address,address,uint256)":{"details":"Transfers `amount` tokens from `from` to `to`. Note: Does not update the allowance if it is the maximum uint256 value. Requirements: - `from` must at least have `amount`. - The caller must have at least `amount` of allowance to transfer the tokens of `from`. Emits a {Transfer} event."},"computeAvailableVestedAmount(address,uint256)":{"params":{"scheduleId":"Schedule ID","beneficiary":"Beneficiary address"},"returns":{"_0":"Amount available to release"}},"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets the voting delegate of the signature signer to `delegatee`."},"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets `value` as the allowance of `spender` over the tokens of `owner`, authorized by a signed approval by `owner`. Emits a {Approval} event."},"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])":{"params":{"name_":"Name of the token","owner_":"Address receiving the ownership of the token","amounts":"Array of amounts for each allocation","symbol_":"Symbol of the token","recipient":"Address receiving the non-vested initial supply","schedules":"Array of vesting schedules","tokenURI_":"Uniform Resource Identifier (URI)","controller_":"Controller address (optional, excluding it prevents disabling the balance limit earlier)","scheduleIds":"Array of schedule IDs corresponding to each allocation","beneficiaries":"Array of beneficiary addresses for allocations","initialSupply":"Initial supply of the token","balanceLimitEnd_":"Balance limit end timestamp","maxBalanceLimit_":"Maximum balance limit","excludedFromBalanceLimit":"Array of addresses to exclude from the balance limit.                                 This should include initializers, migrators, Uniswap PoolManager, treasury, etc."}}},"version":1,"stateVariables":{"_name":{"details":"Name of the token"},"_symbol":{"details":"Symbol of the token"}},"custom:security-contact":"security@whetstone.cc"},"sourceIds":{"src/types/Wad.sol":{"id":6},"src/tokens/DopplerERC20V1.sol":{"id":5},"lib/solady/src/auth/Ownable.sol":{"id":0},"lib/solady/src/tokens/ERC20.sol":{"id":1},"lib/solady/src/tokens/ERC20Votes.sol":{"id":2},"lib/solady/src/utils/LibTransient.sol":{"id":4},"lib/solady/src/utils/Initializable.sol":{"id":3}},"additionalInput":null,"stdJsonInput":{"sources":{"src/types/Wad.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\n/// @dev Constant used to increase precision during calculations\nuint256 constant WAD = 1e18;\n"},"src/tokens/DopplerERC20V1.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.24;\n\nimport { Ownable } from \"solady/auth/Ownable.sol\";\nimport { ERC20 } from \"solady/tokens/ERC20.sol\";\nimport { ERC20Votes } from \"solady/tokens/ERC20Votes.sol\";\nimport { Initializable } from \"solady/utils/Initializable.sol\";\nimport { LibTransient } from \"solady/utils/LibTransient.sol\";\nimport { WAD } from \"src/types/Wad.sol\";\n\n/// @dev Thrown when two arrays have different lengths\nerror ArrayLengthsMismatch();\n\n/// @dev Thrown when trying to transfer tokens into the pool while it is locked\nerror PoolLocked();\n\n/// @dev Thrown when trying to lock the pool while it is already locked\nerror PoolAlreadyLocked();\n\n/// @dev Thrown when trying to unlock the pool while it is already unlocked\nerror PoolAlreadyUnlocked();\n\n/// @dev Thrown when there is no releasable amount\nerror NoReleasableAmount();\n\n/// @dev Thrown when the balance limit is not active\nerror BalanceLimitNotActive();\n\n/// @dev Thrown when the schedule ID is out of range\nerror UnknownScheduleId(uint256 scheduleId);\n\n/// @dev Thrown when a schedule is invalid (violates duration/cliff constraints)\nerror InvalidSchedule(uint256 scheduleId);\n\n/// @dev Thrown when an allocation is invalid (zero address or zero amount)\nerror InvalidAllocation(uint256 index);\n\n/// @dev Thrown when the specified balance limit timestamp is in the past\nerror InvalidBalanceLimitTimestamp(uint256 specified, uint256 current);\n\n/// @dev Thrown when the specified balance limit wad is invalid\nerror InvalidBalanceLimit(uint256 limit);\n\n/// @dev Thrown when an address's balance exceeds the balance limit\nerror BalanceLimitExceeded(uint256 balance, uint256 limit);\n\n/// @dev Thrown when the requested amount is greater than the available amount\nerror InsufficientReleasableAmount(uint256 available, uint256 requested);\n\n/// @dev Thrown when trying to premint more than the maximum allowed per address\nerror MaxPreMintPerAddressExceeded(uint256 amount, uint256 limit);\n\n/// @dev Thrown when trying to premint more than the maximum allowed in total\nerror MaxTotalPreMintExceeded(uint256 amount, uint256 limit);\n\n/// @dev Thrown when trying to mint more than the maximum allowed in total\nerror MaxTotalVestedExceeded(uint256 amount, uint256 limit);\n\n/// @dev Max amount of tokens that can be pre-minted per address (% expressed in WAD)\nuint256 constant MAX_PRE_MINT_PER_ADDRESS_WAD = 0.8 ether;\n\n/// @dev Max amount of tokens that can be pre-minted in total (% expressed in WAD)\nuint256 constant MAX_TOTAL_PRE_MINT_WAD = 0.8 ether;\n\n/// @dev Minimum vesting duration (prevents trivially short vesting periods)\nuint256 constant MIN_VESTING_DURATION = 1 days;\n\n/// @dev Transient storage namespace for initializer schedule deduplication\nbytes32 constant HAS_SCHEDULE_TRANSIENT_SLOT = keccak256(\"doppler.DopplerERC20V1.hasSchedule.transient\");\n\n/**\n * @notice Vesting schedule definition\n * @param cliff Seconds after vestingStart until tokens become claimable\n * @param duration Seconds after vestingStart until fully vested\n */\nstruct VestingSchedule {\n    uint64 cliff;\n    uint64 duration;\n}\n\n/**\n * @notice Vesting data for a specific address\n * @param totalAmount Total amount of vested tokens\n * @param releasedAmount Amount of tokens already released\n */\nstruct VestingData {\n    uint256 totalAmount;\n    uint256 releasedAmount;\n}\n\n/// @notice Emitted when a new vesting schedule is created\nevent VestingScheduleCreated(uint256 indexed scheduleId, uint64 cliff, uint64 duration);\n\n/// @notice Emitted when tokens are allocated to a beneficiary under a schedule\nevent VestingAllocated(address indexed beneficiary, uint256 indexed scheduleId, uint256 amount);\n\n/// @notice Emitted when tokens are released to a beneficiary\nevent TokensReleased(address indexed beneficiary, uint256 indexed scheduleId, uint256 amount);\n\n/// @notice Emitted when the token URI is updated\nevent UpdateTokenURI(string tokenURI);\n\n/// @notice Emitted when the balance limit is disabled\nevent BalanceLimitDisabled(bool expired);\n\n/**\n * @title DopplerERC20 V1.0.0\n * @author Whetstone Research\n * @notice Clonable ERC20 token with multi-schedule vesting, pool lock, votes, max balance limit, and Permit2 support\n * @dev This contract is designed to be cloned using the ERC1167 minimal proxy pattern\n * @custom:security-contact security@whetstone.cc\n */\ncontract DopplerERC20V1 is ERC20, Initializable, Ownable, ERC20Votes {\n    /// @dev Name of the token\n    string private _name;\n\n    /// @dev Symbol of the token\n    string private _symbol;\n\n    /// @notice Uniform Resource Identifier (URI)\n    string public tokenURI;\n\n    /// @notice Timestamp of the start of all vesting schedules\n    uint256 public vestingStart;\n\n    /// @notice Total amount of vested tokens across all beneficiaries and schedules\n    uint256 public vestedTotalAmount;\n\n    /// @notice Controller address (can disable the balance limit)\n    address public controller;\n\n    /// @notice Address of the liquidity pool\n    address public pool;\n\n    /// @notice Whether the pool can receive tokens (unlocked) or not\n    bool public isPoolLocked;\n\n    /// @notice Whether the balance limit is active or not\n    bool public isBalanceLimitActive;\n\n    /// @notice Balance limit end timestamp (in seconds)\n    uint48 public balanceLimitEnd;\n\n    /// @notice Maximum balance limit\n    uint256 public maxBalanceLimit;\n\n    /// @notice Array of vesting schedules (scheduleId = index)\n    VestingSchedule[] public vestingSchedules;\n\n    /// @notice Vesting data for each (beneficiary, scheduleId) pair\n    mapping(address beneficiary => mapping(uint256 scheduleId => VestingData)) public vestingOf;\n\n    /// @notice Total allocated amount per beneficiary (for cap enforcement)\n    mapping(address beneficiary => uint256) public totalAllocatedOf;\n\n    /// @notice List of schedule IDs for each beneficiary\n    mapping(address beneficiary => uint256[]) internal _scheduleIdsOf;\n\n    /// @notice Whether an address is excluded from the balance limit\n    mapping(address account => bool excluded) public isExcludedFromBalanceLimit;\n\n    modifier onlyController() {\n        require(msg.sender == controller, Unauthorized());\n        _;\n    }\n\n    constructor() {\n        _disableInitializers();\n    }\n\n    /**\n     * @notice Initializes the token with the given parameters\n     * @param name_ Name of the token\n     * @param symbol_ Symbol of the token\n     * @param initialSupply Initial supply of the token\n     * @param recipient Address receiving the non-vested initial supply\n     * @param owner_ Address receiving the ownership of the token\n     * @param schedules Array of vesting schedules\n     * @param beneficiaries Array of beneficiary addresses for allocations\n     * @param scheduleIds Array of schedule IDs corresponding to each allocation\n     * @param amounts Array of amounts for each allocation\n     * @param tokenURI_ Uniform Resource Identifier (URI)\n     * @param maxBalanceLimit_ Maximum balance limit\n     * @param balanceLimitEnd_ Balance limit end timestamp\n     * @param controller_ Controller address (optional, excluding it prevents disabling the balance limit earlier)\n     * @param excludedFromBalanceLimit Array of addresses to exclude from the balance limit.\n     *                                 This should include initializers, migrators, Uniswap PoolManager, treasury, etc.\n     */\n    function initialize(\n        string memory name_,\n        string memory symbol_,\n        uint256 initialSupply,\n        address recipient,\n        address owner_,\n        VestingSchedule[] memory schedules,\n        address[] memory beneficiaries,\n        uint256[] memory scheduleIds,\n        uint256[] memory amounts,\n        string memory tokenURI_,\n        uint256 maxBalanceLimit_,\n        uint48 balanceLimitEnd_,\n        address controller_,\n        address[] memory excludedFromBalanceLimit\n    ) external initializer {\n        _initializeOwner(owner_);\n\n        _name = name_;\n        _symbol = symbol_;\n        vestingStart = block.timestamp;\n        tokenURI = tokenURI_;\n\n        if (balanceLimitEnd_ > 0 || maxBalanceLimit_ > 0) {\n            require(maxBalanceLimit_ > 0 && maxBalanceLimit_ < initialSupply, InvalidBalanceLimit(maxBalanceLimit_));\n            require(balanceLimitEnd_ > block.timestamp, InvalidBalanceLimitTimestamp(balanceLimitEnd_, block.timestamp));\n\n            maxBalanceLimit = maxBalanceLimit_;\n            balanceLimitEnd = balanceLimitEnd_;\n            controller = controller_;\n            isBalanceLimitActive = true;\n            isExcludedFromBalanceLimit[owner_] = true;\n            isExcludedFromBalanceLimit[recipient] = true;\n\n            uint256 excludedLength = excludedFromBalanceLimit.length;\n            for (uint256 i; i < excludedLength; ++i) {\n                isExcludedFromBalanceLimit[excludedFromBalanceLimit[i]] = true;\n            }\n        }\n\n        // Validate allocation array lengths\n        uint256 allocationLength = beneficiaries.length;\n        require(allocationLength == scheduleIds.length && allocationLength == amounts.length, ArrayLengthsMismatch());\n\n        // Validate and store schedules\n        uint256 schedulesLength = schedules.length;\n        for (uint256 i; i < schedulesLength; i++) {\n            VestingSchedule memory s = schedules[i];\n            // Duration must be 0 (instant vest) or >= MIN_VESTING_DURATION\n            // Cliff must be <= duration\n            require(\n                (s.duration == 0 || s.duration >= MIN_VESTING_DURATION) && s.cliff <= s.duration, InvalidSchedule(i)\n            );\n            vestingSchedules.push(s);\n            emit VestingScheduleCreated(i, s.cliff, s.duration);\n        }\n\n        // Compute caps\n        uint256 maxPreMintPerAddress = initialSupply * MAX_PRE_MINT_PER_ADDRESS_WAD / WAD;\n        uint256 maxTotalPreMint = initialSupply * MAX_TOTAL_PRE_MINT_WAD / WAD;\n\n        // Process allocations\n        uint256 vestedTokens;\n        for (uint256 i; i < allocationLength; i++) {\n            address beneficiary = beneficiaries[i];\n            uint256 scheduleId = scheduleIds[i];\n            uint256 amount = amounts[i];\n\n            // Validate allocation\n            require(beneficiary != address(0) && amount > 0, InvalidAllocation(i));\n            require(scheduleId < schedulesLength, UnknownScheduleId(scheduleId));\n\n            // Update per-beneficiary allocation and check cap\n            totalAllocatedOf[beneficiary] += amount;\n            uint256 totalAllocated = totalAllocatedOf[beneficiary];\n            require(\n                totalAllocated <= maxPreMintPerAddress,\n                MaxPreMintPerAddressExceeded(totalAllocated, maxPreMintPerAddress)\n            );\n\n            // Update vesting data and exclude from balance limit\n            vestingOf[beneficiary][scheduleId].totalAmount += amount;\n            isExcludedFromBalanceLimit[beneficiary] = true;\n\n            // Track schedule IDs for this beneficiary\n            if (!_hasTransientSchedule(beneficiary, scheduleId)) {\n                _setTransientSchedule(beneficiary, scheduleId);\n                _scheduleIdsOf[beneficiary].push(scheduleId);\n            }\n\n            vestedTokens += amount;\n            emit VestingAllocated(beneficiary, scheduleId, amount);\n        }\n\n        // Enforce total premint cap\n        require(vestedTokens <= maxTotalPreMint, MaxTotalPreMintExceeded(vestedTokens, maxTotalPreMint));\n        require(vestedTokens <= initialSupply, MaxTotalVestedExceeded(vestedTokens, initialSupply));\n\n        vestedTotalAmount = vestedTokens;\n\n        // Mint tokens\n        if (vestedTokens > 0) {\n            _mint(address(this), vestedTokens);\n        }\n        _mint(recipient, initialSupply - vestedTokens);\n    }\n\n    /* ----------------------------------------------------------------------- */\n    /*                                Pool Lock                                */\n    /* ----------------------------------------------------------------------- */\n\n    /**\n     * @notice Locks the pool, preventing it from receiving tokens, and excludes it from the balance limit\n     * @param pool_ Address of the pool to lock\n     */\n    function lockPool(address pool_) external onlyOwner {\n        require(!isPoolLocked, PoolAlreadyLocked());\n        pool = pool_;\n        isPoolLocked = true;\n        isExcludedFromBalanceLimit[pool_] = true;\n    }\n\n    /// @notice Unlocks the pool, allowing it to receive tokens\n    function unlockPool() external onlyOwner {\n        require(isPoolLocked, PoolAlreadyUnlocked());\n        isPoolLocked = false;\n    }\n\n    /* ------------------------------------------------------------------------- */\n    /*                                 Controller                                */\n    /* ------------------------------------------------------------------------- */\n\n    /// @notice Permanently disables the balance limit\n    /// @dev Only callable by the controller, which is set during initialization\n    ///      If the controller was not set, the balance limit cannot be disabled early\n    function disableBalanceLimit() external onlyController {\n        require(isBalanceLimitActive, BalanceLimitNotActive());\n        isBalanceLimitActive = false;\n        emit BalanceLimitDisabled(false);\n    }\n\n    /* ---------------------------------------------------------------------------- */\n    /*                                    Burn                                      */\n    /* ---------------------------------------------------------------------------- */\n\n    /**\n     * @notice Burns `amount` of tokens from the caller's balance\n     * @param amount Amount of tokens to burn\n     */\n    function burn(uint256 amount) external {\n        _burn(msg.sender, amount);\n    }\n\n    /* ---------------------------------------------------------------------------- */\n    /*                                  Token URI                                   */\n    /* ---------------------------------------------------------------------------- */\n\n    /**\n     * @notice Updates the token Uniform Resource Identifier (URI)\n     * @param tokenURI_ New token Uniform Resource Identifier (URI)\n     */\n    function updateTokenURI(string memory tokenURI_) external onlyOwner {\n        tokenURI = tokenURI_;\n        emit UpdateTokenURI(tokenURI_);\n    }\n\n    /* ----------------------------------------------------------------------------- */\n    /*                                Vesting Release                                */\n    /* ----------------------------------------------------------------------------- */\n\n    /**\n     * @notice Releases available vested tokens for a specific schedule\n     * @dev Use 0 for `amount` to release total available amount\n     * @param scheduleId Schedule ID to release from\n     * @param amount Amount of tokens to release\n     */\n    function release(uint256 scheduleId, uint256 amount) external {\n        _releaseFor(msg.sender, scheduleId, amount);\n    }\n\n    /**\n     * @notice Releases all available vested tokens across all schedules for the caller\n     * @dev Use 0 for `amount` to release total available amount\n     * @param amount Amount of tokens to release\n     */\n    function release(uint256 amount) external {\n        _releaseAllFor(msg.sender, amount);\n    }\n\n    /**\n     * @notice Releases available vested tokens for a beneficiary under a specific schedule\n     * @dev Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount\n     * @param beneficiary Bneficiary address\n     * @param scheduleId Schedule ID to release from\n     * @param amount Amount of tokens to release\n     */\n    function releaseFor(address beneficiary, uint256 scheduleId, uint256 amount) external {\n        _releaseFor(beneficiary, scheduleId, amount);\n    }\n\n    /**\n     * @notice Releases all available vested tokens for a beneficiary across all schedules\n     * @dev Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount\n     * @param beneficiary Beneficiary address\n     * @param amount Amount of tokens to release\n     */\n    function releaseFor(address beneficiary, uint256 amount) external {\n        _releaseAllFor(beneficiary, amount);\n    }\n\n    /* --------------------------------------------------------------------- */\n    /*                                Getters                                */\n    /* --------------------------------------------------------------------- */\n\n    /// @notice Returns the number of vesting schedules\n    function vestingScheduleCount() external view returns (uint256) {\n        return vestingSchedules.length;\n    }\n\n    /**\n     * @notice Returns the list of schedule IDs for a beneficiary\n     * @param beneficiary Beneficiary address\n     * @return Array of schedule IDs\n     */\n    function getScheduleIdsOf(address beneficiary) external view returns (uint256[] memory) {\n        return _scheduleIdsOf[beneficiary];\n    }\n\n    /**\n     * @notice Computes the available vested amount for a beneficiary under a specific schedule\n     * @param beneficiary Beneficiary address\n     * @param scheduleId Schedule ID\n     * @return Amount available to release\n     */\n    function computeAvailableVestedAmount(address beneficiary, uint256 scheduleId) public view returns (uint256) {\n        return _available(beneficiary, scheduleId);\n    }\n\n    /**\n     * @notice Computes the total available vested amount for a beneficiary across all schedules\n     * @param beneficiary Beneficiary address\n     * @return total Total amount available to release\n     */\n    function computeAvailableVestedAmount(address beneficiary) public view returns (uint256 total) {\n        uint256[] memory ids = _scheduleIdsOf[beneficiary];\n        uint256 length = ids.length;\n        for (uint256 i; i < length; i++) {\n            total += _available(beneficiary, ids[i]);\n        }\n    }\n\n    /* ----------------------------------------------------------------------- */\n    /*                                Internals                                */\n    /* ----------------------------------------------------------------------- */\n\n    /**\n     * @dev Computes the available (releasable) amount for a beneficiary under a schedule\n     * @param beneficiary Beneficiary address\n     * @param scheduleId Schedule ID\n     * @return Amount available to release\n     */\n    function _available(address beneficiary, uint256 scheduleId) internal view returns (uint256) {\n        VestingData storage vd = vestingOf[beneficiary][scheduleId];\n        uint256 totalAmount = vd.totalAmount;\n        if (totalAmount == 0) return 0;\n\n        VestingSchedule memory s = vestingSchedules[scheduleId];\n        uint256 t = block.timestamp;\n        uint256 start = vestingStart;\n\n        // Cliff gating: nothing claimable before cliff\n        if (t < start + s.cliff) return 0;\n\n        // Linear vesting from start\n        uint256 vested;\n        if (t >= start + s.duration) {\n            vested = totalAmount;\n        } else {\n            vested = (totalAmount * (t - start)) / s.duration;\n        }\n\n        uint256 released = vd.releasedAmount;\n        return vested > released ? vested - released : 0;\n    }\n\n    function _hasTransientSchedule(address beneficiary, uint256 scheduleId) internal view returns (bool) {\n        return LibTransient.get(LibTransient.tBool(_transientScheduleSlot(beneficiary, scheduleId)));\n    }\n\n    function _setTransientSchedule(address beneficiary, uint256 scheduleId) internal {\n        LibTransient.set(LibTransient.tBool(_transientScheduleSlot(beneficiary, scheduleId)), true);\n    }\n\n    function _transientScheduleSlot(address beneficiary, uint256 scheduleId) internal pure returns (bytes32) {\n        return keccak256(abi.encode(HAS_SCHEDULE_TRANSIENT_SLOT, beneficiary, scheduleId));\n    }\n\n    /**\n     * @dev Releases tokens for a beneficiary from a specific schedule\n     * @param beneficiary Beneficiary address\n     * @param scheduleId Schedule ID\n     * @param amount Amount of tokens to release\n     */\n    function _releaseFor(address beneficiary, uint256 scheduleId, uint256 amount) internal {\n        require(scheduleId < vestingSchedules.length, UnknownScheduleId(scheduleId));\n\n        uint256 available = _available(beneficiary, scheduleId);\n        require(available > 0, NoReleasableAmount());\n        if (amount > 0) require(available >= amount, InsufficientReleasableAmount(available, amount));\n        else amount = available;\n\n        vestingOf[beneficiary][scheduleId].releasedAmount += amount;\n        _transfer(address(this), beneficiary, amount);\n        emit TokensReleased(beneficiary, scheduleId, amount);\n    }\n\n    /**\n     * @dev Releases tokens for a beneficiary across all their schedules\n     * @param beneficiary Beneficiary address\n     * @param amount Amount of tokens to release\n     */\n    function _releaseAllFor(address beneficiary, uint256 amount) internal {\n        uint256[] memory ids = _scheduleIdsOf[beneficiary];\n        uint256 length = ids.length;\n\n        // First pass: compute available amounts and total, stop if non-zero amount is reached\n        uint256[] memory amounts = new uint256[](length);\n        uint256 total;\n        for (uint256 i; i < length; i++) {\n            amounts[i] = _available(beneficiary, ids[i]);\n            total += amounts[i];\n            if (amount > 0 && total >= amount) {\n                total = amount;\n                break;\n            }\n        }\n\n        // Ensure a requested amount is available\n        require(total >= amount, InsufficientReleasableAmount(total, amount));\n        amount = total;\n\n        // Ensure a non-zero amount is available\n        require(amount > 0, NoReleasableAmount());\n\n        // Second pass: update state and emit events\n        for (uint256 i; i < length; i++) {\n            if (amounts[i] > 0) {\n                uint256 released = amounts[i] > total ? total : amounts[i];\n                unchecked {\n                    vestingOf[beneficiary][ids[i]].releasedAmount += released;\n                    total -= released;\n                }\n\n                emit TokensReleased(beneficiary, ids[i], released);\n                if (total == 0) break;\n            }\n        }\n\n        // Single transfer\n        _transfer(address(this), beneficiary, amount);\n    }\n\n    /* ----------------------------------------------------------------------- */\n    /*                                Overrides                                */\n    /* ----------------------------------------------------------------------- */\n\n    /// @inheritdoc ERC20\n    function name() public view override returns (string memory) {\n        return _name;\n    }\n\n    /// @inheritdoc ERC20\n    function symbol() public view override returns (string memory) {\n        return _symbol;\n    }\n\n    /// @inheritdoc ERC20\n    function _beforeTokenTransfer(address from, address to, uint256 value) internal override {\n        if (to == pool && isPoolLocked) revert PoolLocked();\n        if (isBalanceLimitActive) {\n            // Exclude self transfers, burns, and vesting mints prior to checking exclusions\n            if (from != to && to != address(0) && to != address(this)) {\n                if (!isExcludedFromBalanceLimit[to]) {\n                    if (block.timestamp < balanceLimitEnd) {\n                        uint256 newBalance = balanceOf(to) + value;\n                        require(newBalance <= maxBalanceLimit, BalanceLimitExceeded(newBalance, maxBalanceLimit));\n                    } else {\n                        // Lazily disable balance limit on first post expiration transfer\n                        isBalanceLimitActive = false;\n                        emit BalanceLimitDisabled(true);\n                    }\n                }\n            }\n        }\n    }\n\n    /// @inheritdoc ERC20\n    function _givePermit2InfiniteAllowance() internal pure override returns (bool) {\n        return true;\n    }\n\n    /// @inheritdoc ERC20Votes\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal override(ERC20Votes, ERC20) {\n        super._afterTokenTransfer(from, to, amount);\n    }\n\n    /// @inheritdoc Ownable\n    function _setOwner(address newOwner) internal override {\n        // Exclude new owners from balance limit to prevent inflation mints from reverting\n        // This is only relevant if the balance limit is still enabled during/after migration\n        if (balanceLimitEnd > block.timestamp) isExcludedFromBalanceLimit[newOwner] = true;\n        super._setOwner(newOwner);\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/tokens/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple ERC20 + EIP-2612 implementation.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)\n///\n/// @dev Note:\n/// - The ERC20 standard allows minting and transferring to and from the zero address,\n///   minting and transferring zero tokens, as well as self-approvals.\n///   For performance, this implementation WILL NOT revert for such actions.\n///   Please add any checks with overrides if desired.\n/// - The `permit` function uses the ecrecover precompile (0x1).\n///\n/// If you are overriding:\n/// - NEVER violate the ERC20 invariant:\n///   the total sum of all balances must be equal to `totalSupply()`.\n/// - Check that the overridden function is actually used in the function you want to\n///   change the behavior of. Much of the code has been manually inlined for performance.\nabstract contract ERC20 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The total supply has overflowed.\n    error TotalSupplyOverflow();\n\n    /// @dev The allowance has overflowed.\n    error AllowanceOverflow();\n\n    /// @dev The allowance has underflowed.\n    error AllowanceUnderflow();\n\n    /// @dev Insufficient balance.\n    error InsufficientBalance();\n\n    /// @dev Insufficient allowance.\n    error InsufficientAllowance();\n\n    /// @dev The permit is invalid.\n    error InvalidPermit();\n\n    /// @dev The permit has expired.\n    error PermitExpired();\n\n    /// @dev The allowance of Permit2 is fixed at infinity.\n    error Permit2AllowanceIsFixedAtInfinity();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n\n    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.\n    event Approval(address indexed owner, address indexed spender, uint256 amount);\n\n    /// @dev `keccak256(bytes(\"Transfer(address,address,uint256)\"))`.\n    uint256 private constant _TRANSFER_EVENT_SIGNATURE =\n        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;\n\n    /// @dev `keccak256(bytes(\"Approval(address,address,uint256)\"))`.\n    uint256 private constant _APPROVAL_EVENT_SIGNATURE =\n        0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The storage slot for the total supply.\n    uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;\n\n    /// @dev The balance slot of `owner` is given by:\n    /// ```\n    ///     mstore(0x0c, _BALANCE_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let balanceSlot := keccak256(0x0c, 0x20)\n    /// ```\n    uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;\n\n    /// @dev The allowance slot of (`owner`, `spender`) is given by:\n    /// ```\n    ///     mstore(0x20, spender)\n    ///     mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let allowanceSlot := keccak256(0x0c, 0x34)\n    /// ```\n    uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;\n\n    /// @dev The nonce slot of `owner` is given by:\n    /// ```\n    ///     mstore(0x0c, _NONCES_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let nonceSlot := keccak256(0x0c, 0x20)\n    /// ```\n    uint256 private constant _NONCES_SLOT_SEED = 0x38377508;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev `(_NONCES_SLOT_SEED << 16) | 0x1901`.\n    uint256 private constant _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX = 0x383775081901;\n\n    /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n    bytes32 private constant _DOMAIN_TYPEHASH =\n        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n    /// @dev `keccak256(\"1\")`.\n    /// If you need to use a different version, override `_versionHash`.\n    bytes32 private constant _DEFAULT_VERSION_HASH =\n        0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;\n\n    /// @dev `keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\")`.\n    bytes32 private constant _PERMIT_TYPEHASH =\n        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n\n    /// @dev The canonical Permit2 address.\n    /// For signature-based allowance granting for single transaction ERC20 `transferFrom`.\n    /// To enable, override `_givePermit2InfiniteAllowance()`.\n    /// [Github](https://github.com/Uniswap/permit2)\n    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n    address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ERC20 METADATA                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the name of the token.\n    function name() public view virtual returns (string memory);\n\n    /// @dev Returns the symbol of the token.\n    function symbol() public view virtual returns (string memory);\n\n    /// @dev Returns the decimals places of the token.\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           ERC20                            */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the amount of tokens in existence.\n    function totalSupply() public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_TOTAL_SUPPLY_SLOT)\n        }\n    }\n\n    /// @dev Returns the amount of tokens owned by `owner`.\n    function balanceOf(address owner) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.\n    function allowance(address owner, address spender)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        if (_givePermit2InfiniteAllowance()) {\n            if (spender == _PERMIT2) return type(uint256).max;\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x34))\n        }\n    }\n\n    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n    ///\n    /// Emits a {Approval} event.\n    function approve(address spender, uint256 amount) public virtual returns (bool) {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && amount != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the allowance slot and store the amount.\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x34), amount)\n            // Emit the {Approval} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))\n        }\n        return true;\n    }\n\n    /// @dev Transfer `amount` tokens from the caller to `to`.\n    ///\n    /// Requirements:\n    /// - `from` must at least have `amount`.\n    ///\n    /// Emits a {Transfer} event.\n    function transfer(address to, uint256 amount) public virtual returns (bool) {\n        _beforeTokenTransfer(msg.sender, to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, caller())\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Compute the balance slot of `to`.\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance of `to`.\n            // Will not overflow because the sum of all user balances\n            // cannot exceed the maximum uint256 value.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(msg.sender, to, amount);\n        return true;\n    }\n\n    /// @dev Transfers `amount` tokens from `from` to `to`.\n    ///\n    /// Note: Does not update the allowance if it is the maximum uint256 value.\n    ///\n    /// Requirements:\n    /// - `from` must at least have `amount`.\n    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.\n    ///\n    /// Emits a {Transfer} event.\n    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {\n        _beforeTokenTransfer(from, to, amount);\n        // Code duplication is for zero-cost abstraction if possible.\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let from_ := shl(96, from)\n                if iszero(eq(caller(), _PERMIT2)) {\n                    // Compute the allowance slot and load its value.\n                    mstore(0x20, caller())\n                    mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n                    let allowanceSlot := keccak256(0x0c, 0x34)\n                    let allowance_ := sload(allowanceSlot)\n                    // If the allowance is not the maximum uint256 value.\n                    if not(allowance_) {\n                        // Revert if the amount to be transferred exceeds the allowance.\n                        if gt(amount, allowance_) {\n                            mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                            revert(0x1c, 0x04)\n                        }\n                        // Subtract and store the updated allowance.\n                        sstore(allowanceSlot, sub(allowance_, amount))\n                    }\n                }\n                // Compute the balance slot and load its value.\n                mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n                let fromBalanceSlot := keccak256(0x0c, 0x20)\n                let fromBalance := sload(fromBalanceSlot)\n                // Revert if insufficient balance.\n                if gt(amount, fromBalance) {\n                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated balance.\n                sstore(fromBalanceSlot, sub(fromBalance, amount))\n                // Compute the balance slot of `to`.\n                mstore(0x00, to)\n                let toBalanceSlot := keccak256(0x0c, 0x20)\n                // Add and store the updated balance of `to`.\n                // Will not overflow because the sum of all user balances\n                // cannot exceed the maximum uint256 value.\n                sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n                // Emit the {Transfer} event.\n                mstore(0x20, amount)\n                log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let from_ := shl(96, from)\n                // Compute the allowance slot and load its value.\n                mstore(0x20, caller())\n                mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n                let allowanceSlot := keccak256(0x0c, 0x34)\n                let allowance_ := sload(allowanceSlot)\n                // If the allowance is not the maximum uint256 value.\n                if not(allowance_) {\n                    // Revert if the amount to be transferred exceeds the allowance.\n                    if gt(amount, allowance_) {\n                        mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                        revert(0x1c, 0x04)\n                    }\n                    // Subtract and store the updated allowance.\n                    sstore(allowanceSlot, sub(allowance_, amount))\n                }\n                // Compute the balance slot and load its value.\n                mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n                let fromBalanceSlot := keccak256(0x0c, 0x20)\n                let fromBalance := sload(fromBalanceSlot)\n                // Revert if insufficient balance.\n                if gt(amount, fromBalance) {\n                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated balance.\n                sstore(fromBalanceSlot, sub(fromBalance, amount))\n                // Compute the balance slot of `to`.\n                mstore(0x00, to)\n                let toBalanceSlot := keccak256(0x0c, 0x20)\n                // Add and store the updated balance of `to`.\n                // Will not overflow because the sum of all user balances\n                // cannot exceed the maximum uint256 value.\n                sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n                // Emit the {Transfer} event.\n                mstore(0x20, amount)\n                log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n            }\n        }\n        _afterTokenTransfer(from, to, amount);\n        return true;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          EIP-2612                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For more performance, override to return the constant value\n    /// of `keccak256(bytes(name()))` if `name()` will never change.\n    function _constantNameHash() internal view virtual returns (bytes32 result) {}\n\n    /// @dev If you need a different value, override this function.\n    function _versionHash() internal view virtual returns (bytes32 result) {\n        result = _DEFAULT_VERSION_HASH;\n    }\n\n    /// @dev For inheriting contracts to increment the nonce.\n    function _incrementNonce(address owner) internal virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _NONCES_SLOT_SEED)\n            mstore(0x00, owner)\n            let nonceSlot := keccak256(0x0c, 0x20)\n            sstore(nonceSlot, add(1, sload(nonceSlot)))\n        }\n    }\n\n    /// @dev Returns the current nonce for `owner`.\n    /// This value is used to compute the signature for EIP-2612 permit.\n    function nonces(address owner) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the nonce slot and load its value.\n            mstore(0x0c, _NONCES_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Sets `value` as the allowance of `spender` over the tokens of `owner`,\n    /// authorized by a signed approval by `owner`.\n    ///\n    /// Emits a {Approval} event.\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && value != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(value)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Revert if the block timestamp is greater than `deadline`.\n            if gt(timestamp(), deadline) {\n                mstore(0x00, 0x1a15a3cc) // `PermitExpired()`.\n                revert(0x1c, 0x04)\n            }\n            let m := mload(0x40) // Grab the free memory pointer.\n            // Clean the upper 96 bits.\n            owner := shr(96, shl(96, owner))\n            spender := shr(96, shl(96, spender))\n            // Compute the nonce slot and load its value.\n            mstore(0x0e, _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX)\n            mstore(0x00, owner)\n            let nonceSlot := keccak256(0x0c, 0x20)\n            let nonceValue := sload(nonceSlot)\n            // Prepare the domain separator.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            mstore(0x2e, keccak256(m, 0xa0))\n            // Prepare the struct hash.\n            mstore(m, _PERMIT_TYPEHASH)\n            mstore(add(m, 0x20), owner)\n            mstore(add(m, 0x40), spender)\n            mstore(add(m, 0x60), value)\n            mstore(add(m, 0x80), nonceValue)\n            mstore(add(m, 0xa0), deadline)\n            mstore(0x4e, keccak256(m, 0xc0))\n            // Prepare the ecrecover calldata.\n            mstore(0x00, keccak256(0x2c, 0x42))\n            mstore(0x20, and(0xff, v))\n            mstore(0x40, r)\n            mstore(0x60, s)\n            let t := staticcall(gas(), 1, 0x00, 0x80, 0x20, 0x20)\n            // If the ecrecover fails, the returndatasize will be 0x00,\n            // `owner` will be checked if it equals the hash at 0x00,\n            // which evaluates to false (i.e. 0), and we will revert.\n            // If the ecrecover succeeds, the returndatasize will be 0x20,\n            // `owner` will be compared against the returned address at 0x20.\n            if iszero(eq(mload(returndatasize()), owner)) {\n                mstore(0x00, 0xddafbaef) // `InvalidPermit()`.\n                revert(0x1c, 0x04)\n            }\n            // Increment and store the updated nonce.\n            sstore(nonceSlot, add(nonceValue, t)) // `t` is 1 if ecrecover succeeds.\n            // Compute the allowance slot and store the value.\n            // The `owner` is already at slot 0x20.\n            mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))\n            sstore(keccak256(0x2c, 0x34), value)\n            // Emit the {Approval} event.\n            log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero pointer.\n        }\n    }\n\n    /// @dev Returns the EIP-712 domain separator for the EIP-2612 permit.\n    function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Grab the free memory pointer.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            result := keccak256(m, 0xa0)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  INTERNAL MINT FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Mints `amount` tokens to `to`, increasing the total supply.\n    ///\n    /// Emits a {Transfer} event.\n    function _mint(address to, uint256 amount) internal virtual {\n        _beforeTokenTransfer(address(0), to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)\n            let totalSupplyAfter := add(totalSupplyBefore, amount)\n            // Revert if the total supply overflows.\n            if lt(totalSupplyAfter, totalSupplyBefore) {\n                mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.\n                revert(0x1c, 0x04)\n            }\n            // Store the updated total supply.\n            sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(address(0), to, amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  INTERNAL BURN FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Burns `amount` tokens from `from`, reducing the total supply.\n    ///\n    /// Emits a {Transfer} event.\n    function _burn(address from, uint256 amount) internal virtual {\n        _beforeTokenTransfer(from, address(0), amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, from)\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Subtract and store the updated total supply.\n            sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))\n            // Emit the {Transfer} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)\n        }\n        _afterTokenTransfer(from, address(0), amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                INTERNAL TRANSFER FUNCTIONS                 */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Moves `amount` of tokens from `from` to `to`.\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        _beforeTokenTransfer(from, to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let from_ := shl(96, from)\n            // Compute the balance slot and load its value.\n            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Compute the balance slot of `to`.\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance of `to`.\n            // Will not overflow because the sum of all user balances\n            // cannot exceed the maximum uint256 value.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                INTERNAL ALLOWANCE FUNCTIONS                */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            if (spender == _PERMIT2) return; // Do nothing, as allowance is infinite.\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the allowance slot and load its value.\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            let allowanceSlot := keccak256(0x0c, 0x34)\n            let allowance_ := sload(allowanceSlot)\n            // If the allowance is not the maximum uint256 value.\n            if not(allowance_) {\n                // Revert if the amount to be transferred exceeds the allowance.\n                if gt(amount, allowance_) {\n                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated allowance.\n                sstore(allowanceSlot, sub(allowance_, amount))\n            }\n        }\n    }\n\n    /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.\n    ///\n    /// Emits a {Approval} event.\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && amount != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            let owner_ := shl(96, owner)\n            // Compute the allowance slot and store the amount.\n            mstore(0x20, spender)\n            mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))\n            sstore(keccak256(0x0c, 0x34), amount)\n            // Emit the {Approval} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     HOOKS TO OVERRIDE                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Hook that is called before any transfer of tokens.\n    /// This includes minting and burning.\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /// @dev Hook that is called after any transfer of tokens.\n    /// This includes minting and burning.\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          PERMIT2                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns whether to fix the Permit2 contract's allowance at infinity.\n    ///\n    /// This value should be kept constant after contract initialization,\n    /// or else the actual allowance values may not match with the {Approval} events.\n    /// For best performance, return a compile-time constant for zero-cost abstraction.\n    function _givePermit2InfiniteAllowance() internal view virtual returns (bool) {\n        return false;\n    }\n}\n"},"lib/solady/src/tokens/ERC20Votes.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {ERC20} from \"./ERC20.sol\";\n\n/// @notice ERC20 with votes based on ERC5805 and ERC6372.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20Votes.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Votes.sol)\nabstract contract ERC20Votes is ERC20 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The timepoint is in the future.\n    error ERC5805FutureLookup();\n\n    /// @dev The ERC5805 signature to set a delegate has expired.\n    error ERC5805DelegateSignatureExpired();\n\n    /// @dev The ERC5805 signature to set a delegate is invalid.\n    error ERC5805DelegateInvalidSignature();\n\n    /// @dev Out-of-bounds access for the checkpoints.\n    error ERC5805CheckpointIndexOutOfBounds();\n\n    /// @dev Arithmetic overflow when pushing a new checkpoint.\n    error ERC5805CheckpointValueOverflow();\n\n    /// @dev Arithmetic underflow when pushing a new checkpoint.\n    error ERC5805CheckpointValueUnderflow();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The delegate of `delegator` is changed from `from` to `to`.\n    event DelegateChanged(address indexed delegator, address indexed from, address indexed to);\n\n    /// @dev The votes balance of `delegate` is changed from `oldValue` to `newValue`.\n    event DelegateVotesChanged(address indexed delegate, uint256 oldValue, uint256 newValue);\n\n    /// @dev `keccak256(bytes(\"DelegateChanged(address,address,address)\"))`.\n    uint256 private constant _DELEGATE_CHANGED_EVENT_SIGNATURE =\n        0x3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f;\n\n    /// @dev `keccak256(bytes(\"DelegateVotesChanged(address,uint256,uint256)\"))`.\n    uint256 private constant _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE =\n        0xdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a724;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n    bytes32 private constant _DOMAIN_TYPEHASH =\n        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n    /// @dev `keccak256(\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\")`.\n    bytes32 private constant _ERC5805_DELEGATION_TYPEHASH =\n        0xe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The slot of a delegate is given by:\n    /// ```\n    ///     mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n    ///     mstore(0x00, account)\n    ///     let delegateSlot := keccak256(0x0c, 0x18)\n    /// ```\n    /// The checkpoints length slot of a delegate is given by:\n    /// ```\n    ///     mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n    ///     mstore(0x00, delegate)\n    ///     let lengthSlot := keccak256(0x0c, 0x17)\n    ///     let length := and(0xffffffffffff, shr(48, sload(lengthSlot)))\n    /// ```\n    /// The total checkpoints length slot is `_ERC20_VOTES_MASTER_SLOT_SEED << 96`.\n    ///\n    /// The `i`-th checkpoint slot is given by:\n    /// ```\n    ///     let checkpointSlot := add(i, lengthSlot)\n    ///     let key := and(sload(checkpointSlot), 0xffffffffffff)\n    ///     let value := shr(96, sload(checkpointSlot))\n    ///     if eq(value, address()) { value := sload(not(checkpointSlot)) }\n    /// ```\n    uint256 private constant _ERC20_VOTES_MASTER_SLOT_SEED = 0xff466c9f;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          ERC6372                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the clock mode.\n    function CLOCK_MODE() public view virtual returns (string memory) {\n        return \"mode=blocknumber&from=default\";\n    }\n\n    /// @dev Retusn the current clock.\n    function clock() public view returns (uint48 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := number()\n            // Branch-less out-of-gas revert if `block.number >= 2 ** 48`.\n            returndatacopy(returndatasize(), returndatasize(), sub(0, shr(48, number())))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          ERC5805                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the latest amount of voting units for `account`.\n    function getVotes(address account) public view virtual returns (uint256) {\n        return _checkpointLatest(_delegateCheckpointsSlot(account));\n    }\n\n    /// @dev Returns the latest amount of voting units `account` has before `timepoint`.\n    function getPastVotes(address account, uint256 timepoint)\n        public\n        view\n        virtual\n        returns (uint256)\n    {\n        if (timepoint >= clock()) _revertERC5805FutureLookup();\n        return _checkpointUpperLookupRecent(_delegateCheckpointsSlot(account), timepoint);\n    }\n\n    /// @dev Returns the current voting delegate of `delegator`.\n    function delegates(address delegator) public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, delegator)\n            result := sload(keccak256(0x0c, 0x18))\n        }\n    }\n\n    /// @dev Set the voting delegate of the caller to `delegatee`.\n    function delegate(address delegatee) public virtual {\n        _delegate(msg.sender, delegatee);\n    }\n\n    /// @dev Sets the voting delegate of the signature signer to `delegatee`.\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        address signer;\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if gt(timestamp(), expiry) {\n                mstore(0x00, 0x3480e9e1) // `ERC5805DelegateSignatureExpired()`.\n                revert(0x1c, 0x04)\n            }\n            let m := mload(0x40)\n            // Prepare the struct hash.\n            mstore(0x00, _ERC5805_DELEGATION_TYPEHASH)\n            mstore(0x20, shr(96, shl(96, delegatee)))\n            mstore(0x40, nonce)\n            mstore(0x60, expiry)\n            mstore(0x40, keccak256(0x00, 0x80))\n            mstore(0x00, 0x1901) // Store \"\\x19\\x01\".\n            // Prepare the domain separator.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            mstore(0x20, keccak256(m, 0xa0))\n            // Prepare the ecrecover calldata.\n            mstore(0x00, keccak256(0x1e, 0x42))\n            mstore(0x20, and(0xff, v))\n            mstore(0x40, r)\n            mstore(0x60, s)\n            signer := mload(staticcall(gas(), 1, 0x00, 0x80, 0x01, 0x20))\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero pointer.\n            // `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.\n            expiry := iszero(returndatasize()) // Reuse `expiry` to denote `ecrecover` failure.\n        }\n        if ((nonces(signer) ^ nonce) | expiry != 0) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                mstore(0x00, 0x1838d95c) // `ERC5805DelegateInvalidSignature()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _incrementNonce(signer);\n        _delegate(signer, delegatee);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*              OTHER VOTE PUBLIC VIEW FUNCTIONS              */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the number of checkpoints for `account`.\n    function checkpointCount(address account) public view virtual returns (uint256 result) {\n        result = _delegateCheckpointsSlot(account);\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(208, shl(160, sload(result)))\n        }\n    }\n\n    /// @dev Returns the voting checkpoint for `account` at index `i`.\n    function checkpointAt(address account, uint256 i)\n        public\n        view\n        virtual\n        returns (uint48 checkpointClock, uint256 checkpointValue)\n    {\n        uint256 lengthSlot = _delegateCheckpointsSlot(account);\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(lt(i, shr(208, shl(160, sload(lengthSlot))))) {\n                mstore(0x00, 0x86df9d10) // `ERC5805CheckpointIndexOutOfBounds()`.\n                revert(0x1c, 0x04)\n            }\n            let checkpointPacked := sload(add(i, lengthSlot))\n            checkpointClock := and(0xffffffffffff, checkpointPacked)\n            checkpointValue := shr(96, checkpointPacked)\n            if eq(checkpointValue, address()) { checkpointValue := sload(not(add(i, lengthSlot))) }\n        }\n    }\n\n    /// @dev Returns the latest amount of total voting units.\n    function getVotesTotalSupply() public view virtual returns (uint256) {\n        return _checkpointLatest(_ERC20_VOTES_MASTER_SLOT_SEED << 96);\n    }\n\n    /// @dev Returns the latest amount of total voting units before `timepoint`.\n    function getPastVotesTotalSupply(uint256 timepoint) public view virtual returns (uint256) {\n        if (timepoint >= clock()) _revertERC5805FutureLookup();\n        return _checkpointUpperLookupRecent(_ERC20_VOTES_MASTER_SLOT_SEED << 96, timepoint);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the amount of voting units `delegator` has control over.\n    /// Override if you need a different formula.\n    function _getVotingUnits(address delegator) internal view virtual returns (uint256) {\n        return balanceOf(delegator);\n    }\n\n    /// @dev ERC20 after token transfer internal hook.\n    function _afterTokenTransfer(address from, address to, uint256 amount)\n        internal\n        virtual\n        override\n    {\n        _transferVotingUnits(from, to, amount);\n    }\n\n    /// @dev Used in `_afterTokenTransfer(address from, address to, uint256 amount)`.\n    function _transferVotingUnits(address from, address to, uint256 amount) internal virtual {\n        if (from == address(0)) {\n            _checkpointPushDiff(_ERC20_VOTES_MASTER_SLOT_SEED << 96, clock(), amount, true);\n        }\n        if (to == address(0)) {\n            _checkpointPushDiff(_ERC20_VOTES_MASTER_SLOT_SEED << 96, clock(), amount, false);\n        }\n        _moveDelegateVotes(delegates(from), delegates(to), amount);\n    }\n\n    /// @dev Transfer `amount` of delegated votes from `from` to `to`.\n    /// Emits a {DelegateVotesChanged} event for each change of delegated votes.\n    function _moveDelegateVotes(address from, address to, uint256 amount) internal virtual {\n        if (amount == uint256(0)) return;\n        (uint256 fromCleaned, uint256 toCleaned) = (uint256(uint160(from)), uint256(uint160(to)));\n        if (fromCleaned == toCleaned) return;\n        if (fromCleaned != 0) {\n            (uint256 oldValue, uint256 newValue) =\n                _checkpointPushDiff(_delegateCheckpointsSlot(from), clock(), amount, false);\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Emit the {DelegateVotesChanged} event.\n                mstore(0x00, oldValue)\n                mstore(0x20, newValue)\n                log2(0x00, 0x40, _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE, fromCleaned)\n            }\n        }\n        if (toCleaned != 0) {\n            (uint256 oldValue, uint256 newValue) =\n                _checkpointPushDiff(_delegateCheckpointsSlot(to), clock(), amount, true);\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Emit the {DelegateVotesChanged} event.\n                mstore(0x00, oldValue)\n                mstore(0x20, newValue)\n                log2(0x00, 0x40, _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE, toCleaned)\n            }\n        }\n    }\n\n    /// @dev Delegates all of `account`'s voting units to `delegatee`.\n    /// Emits the {DelegateChanged} and {DelegateVotesChanged} events.\n    function _delegate(address account, address delegatee) internal virtual {\n        address from;\n        /// @solidity memory-safe-assembly\n        assembly {\n            let to := shr(96, shl(96, delegatee))\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, account)\n            let delegateSlot := keccak256(0x0c, 0x18)\n            from := sload(delegateSlot)\n            sstore(delegateSlot, to)\n            // Emit the {DelegateChanged} event.\n            log4(0x00, 0x00, _DELEGATE_CHANGED_EVENT_SIGNATURE, shr(96, mload(0x0c)), from, to)\n        }\n        _moveDelegateVotes(from, delegatee, _getVotingUnits(account));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the delegate checkpoints slot for `account`.\n    function _delegateCheckpointsSlot(address account) private pure returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, account)\n            result := keccak256(0x0c, 0x17)\n        }\n    }\n\n    /// @dev Pushes a checkpoint.\n    function _checkpointPushDiff(uint256 lengthSlot, uint256 key, uint256 amount, bool isAdd)\n        private\n        returns (uint256 oldValue, uint256 newValue)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let lengthSlotPacked := sload(lengthSlot)\n            for { let n := shr(208, shl(160, lengthSlotPacked)) } 1 {} {\n                if iszero(n) {\n                    if iszero(or(isAdd, iszero(amount))) {\n                        mstore(0x00, 0x5915f686) // `ERC5805CheckpointValueUnderflow()`.\n                        revert(0x1c, 0x04)\n                    }\n                    newValue := amount\n                    if iszero(or(eq(newValue, address()), shr(160, newValue))) {\n                        sstore(lengthSlot, or(or(key, shl(48, 1)), shl(96, newValue)))\n                        break\n                    }\n                    sstore(lengthSlot, or(or(key, shl(48, 1)), shl(96, address())))\n                    sstore(not(lengthSlot), newValue)\n                    break\n                }\n                let checkpointSlot := add(sub(n, 1), lengthSlot)\n                let lastPacked := sload(checkpointSlot)\n                oldValue := shr(96, lastPacked)\n                if eq(oldValue, address()) { oldValue := sload(not(checkpointSlot)) }\n                for {} 1 {} {\n                    if iszero(isAdd) {\n                        newValue := sub(oldValue, amount)\n                        if iszero(gt(newValue, oldValue)) { break }\n                        mstore(0x00, 0x5915f686) // `ERC5805CheckpointValueUnderflow()`.\n                        revert(0x1c, 0x04)\n                    }\n                    newValue := add(oldValue, amount)\n                    if iszero(lt(newValue, oldValue)) { break }\n                    mstore(0x00, 0x9dbbeb75) // `ERC5805CheckpointValueOverflow()`.\n                    revert(0x1c, 0x04)\n                }\n                let lastKey := and(0xffffffffffff, lastPacked)\n                if iszero(eq(lastKey, key)) {\n                    n := add(1, n)\n                    checkpointSlot := add(1, checkpointSlot)\n                    sstore(lengthSlot, add(shl(48, 1), lengthSlotPacked))\n                }\n                if or(gt(lastKey, key), shr(48, n)) { invalid() }\n                if iszero(or(eq(newValue, address()), shr(160, newValue))) {\n                    sstore(checkpointSlot, or(or(key, shl(48, n)), shl(96, newValue)))\n                    break\n                }\n                sstore(checkpointSlot, or(or(key, shl(48, n)), shl(96, address())))\n                sstore(not(checkpointSlot), newValue)\n                break\n            }\n        }\n    }\n\n    /// @dev Returns the latest value in the checkpoints.\n    function _checkpointLatest(uint256 lengthSlot) private view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(208, shl(160, sload(lengthSlot)))\n            if result {\n                lengthSlot := add(sub(result, 1), lengthSlot) // Reuse for `checkpointSlot`.\n                result := shr(96, sload(lengthSlot))\n                if eq(result, address()) { result := sload(not(lengthSlot)) }\n            }\n        }\n    }\n\n    /// @dev Returns the value in the checkpoints with the largest key that is less than `key`.\n    function _checkpointUpperLookupRecent(uint256 lengthSlot, uint256 key)\n        private\n        view\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let l := 0 // Low.\n            let h := shr(208, shl(160, sload(lengthSlot))) // High.\n            // Start the binary search nearer to the right to optimize for recent checkpoints.\n            for {} iszero(lt(h, 6)) {} {\n                let m := shl(4, lt(0xffff, h))\n                m := shl(shr(1, or(m, shl(3, lt(0xff, shr(m, h))))), 16)\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := sub(h, shr(1, add(m, div(h, m)))) // Approx `h - sqrt(h)`.\n                if iszero(lt(key, and(sload(add(m, lengthSlot)), 0xffffffffffff))) {\n                    l := add(1, m)\n                    break\n                }\n                h := m\n                break\n            }\n            // Binary search.\n            for {} lt(l, h) {} {\n                let m := shr(1, add(l, h)) // Won't overflow in practice.\n                if iszero(lt(key, and(sload(add(m, lengthSlot)), 0xffffffffffff))) {\n                    l := add(1, m)\n                    continue\n                }\n                h := m\n            }\n            let checkpointSlot := add(sub(h, 1), lengthSlot)\n            result := mul(iszero(iszero(h)), shr(96, sload(checkpointSlot)))\n            if eq(result, address()) { result := sload(not(checkpointSlot)) }\n        }\n    }\n\n    /// @dev Reverts with `ERC5805FutureLookup()`.\n    function _revertERC5805FutureLookup() private pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0xf9874464) // `ERC5805FutureLookup()`.\n            revert(0x1c, 0x04)\n        }\n    }\n}\n"},"lib/solady/src/utils/LibTransient.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Library for RLP encoding and CREATE address computation.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibTransient.sol)\n/// @author Modified from Transient Goodies by Philogy (https://github.com/Philogy/transient-goodies/blob/main/src/TransientBytesLib.sol)\n///\n/// @dev Note: The functions postfixed with `Compat` will only use transient storage on L1.\n/// L2s are super cheap anyway.\n/// For best safety, always clear the storage after use.\nlibrary LibTransient {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STRUCTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Pointer struct to a `uint256` in transient storage.\n    struct TUint256 {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `int256` in transient storage.\n    struct TInt256 {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `bytes32` in transient storage.\n    struct TBytes32 {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `address` in transient storage.\n    struct TAddress {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `bool` in transient storage.\n    struct TBool {\n        uint256 _spacer;\n    }\n\n    /// @dev Pointer struct to a `bytes` in transient storage.\n    struct TBytes {\n        uint256 _spacer;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The storage slot seed for converting a transient slot to a storage slot.\n    /// `bytes4(keccak256(\"_LIB_TRANSIENT_COMPAT_SLOT_SEED\"))`.\n    uint256 private constant _LIB_TRANSIENT_COMPAT_SLOT_SEED = 0x5a0b45f2;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     UINT256 OPERATIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `uint256` in transient storage.\n    function tUint256(bytes32 tSlot) internal pure returns (TUint256 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `uint256` in transient storage.\n    function tUint256(uint256 tSlot) internal pure returns (TUint256 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TUint256 storage ptr) internal view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TUint256 storage ptr) internal view returns (uint256 result) {\n        result = block.chainid == 1 ? get(ptr) : _compat(ptr)._spacer;\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TUint256 storage ptr, uint256 value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, value)\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TUint256 storage ptr, uint256 value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        _compat(ptr)._spacer = value;\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TUint256 storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TUint256 storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /// @dev Increments the value at transient `ptr` by 1.\n    function inc(TUint256 storage ptr) internal returns (uint256 newValue) {\n        set(ptr, newValue = get(ptr) + 1);\n    }\n\n    /// @dev Increments the value at transient `ptr` by 1.\n    function incCompat(TUint256 storage ptr) internal returns (uint256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) + 1);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function inc(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {\n        set(ptr, newValue = get(ptr) + delta);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function incCompat(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) + delta);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by 1.\n    function dec(TUint256 storage ptr) internal returns (uint256 newValue) {\n        set(ptr, newValue = get(ptr) - 1);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decCompat(TUint256 storage ptr) internal returns (uint256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) - 1);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function dec(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {\n        set(ptr, newValue = get(ptr) - delta);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decCompat(TUint256 storage ptr, uint256 delta) internal returns (uint256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) - delta);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function incSigned(TUint256 storage ptr, int256 delta) internal returns (uint256 newValue) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let currentValue := tload(ptr.slot)\n            newValue := add(currentValue, delta)\n            if iszero(eq(lt(newValue, currentValue), slt(delta, 0))) {\n                mstore(0x00, 0x4e487b71) // `Panic(uint256)`.\n                mstore(0x20, 0x11) // Underflow or overflow panic.\n                revert(0x1c, 0x24)\n            }\n            tstore(ptr.slot, newValue)\n        }\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function incSignedCompat(TUint256 storage ptr, int256 delta)\n        internal\n        returns (uint256 newValue)\n    {\n        if (block.chainid == 1) return incSigned(ptr, delta);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let currentValue := sload(ptr.slot)\n            newValue := add(currentValue, delta)\n            if iszero(eq(lt(newValue, currentValue), slt(delta, 0))) {\n                mstore(0x00, 0x4e487b71) // `Panic(uint256)`.\n                mstore(0x20, 0x11) // Underflow or overflow panic.\n                revert(0x1c, 0x24)\n            }\n            sstore(ptr.slot, newValue)\n        }\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decSigned(TUint256 storage ptr, int256 delta) internal returns (uint256 newValue) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let currentValue := tload(ptr.slot)\n            newValue := sub(currentValue, delta)\n            if iszero(eq(lt(newValue, currentValue), sgt(delta, 0))) {\n                mstore(0x00, 0x4e487b71) // `Panic(uint256)`.\n                mstore(0x20, 0x11) // Underflow or overflow panic.\n                revert(0x1c, 0x24)\n            }\n            tstore(ptr.slot, newValue)\n        }\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decSignedCompat(TUint256 storage ptr, int256 delta)\n        internal\n        returns (uint256 newValue)\n    {\n        if (block.chainid == 1) return decSigned(ptr, delta);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let currentValue := sload(ptr.slot)\n            newValue := sub(currentValue, delta)\n            if iszero(eq(lt(newValue, currentValue), sgt(delta, 0))) {\n                mstore(0x00, 0x4e487b71) // `Panic(uint256)`.\n                mstore(0x20, 0x11) // Underflow or overflow panic.\n                revert(0x1c, 0x24)\n            }\n            sstore(ptr.slot, newValue)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INT256 OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `int256` in transient storage.\n    function tInt256(bytes32 tSlot) internal pure returns (TInt256 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `int256` in transient storage.\n    function tInt256(uint256 tSlot) internal pure returns (TInt256 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TInt256 storage ptr) internal view returns (int256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TInt256 storage ptr) internal view returns (int256 result) {\n        result = block.chainid == 1 ? get(ptr) : int256(_compat(ptr)._spacer);\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TInt256 storage ptr, int256 value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, value)\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TInt256 storage ptr, int256 value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        _compat(ptr)._spacer = uint256(value);\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TInt256 storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TInt256 storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /// @dev Increments the value at transient `ptr` by 1.\n    function inc(TInt256 storage ptr) internal returns (int256 newValue) {\n        set(ptr, newValue = get(ptr) + 1);\n    }\n\n    /// @dev Increments the value at transient `ptr` by 1.\n    function incCompat(TInt256 storage ptr) internal returns (int256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) + 1);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function inc(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {\n        set(ptr, newValue = get(ptr) + delta);\n    }\n\n    /// @dev Increments the value at transient `ptr` by `delta`.\n    function incCompat(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) + delta);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by 1.\n    function dec(TInt256 storage ptr) internal returns (int256 newValue) {\n        set(ptr, newValue = get(ptr) - 1);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by 1.\n    function decCompat(TInt256 storage ptr) internal returns (int256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) - 1);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function dec(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {\n        set(ptr, newValue = get(ptr) - delta);\n    }\n\n    /// @dev Decrements the value at transient `ptr` by `delta`.\n    function decCompat(TInt256 storage ptr, int256 delta) internal returns (int256 newValue) {\n        setCompat(ptr, newValue = getCompat(ptr) - delta);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     BYTES32 OPERATIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `bytes32` in transient storage.\n    function tBytes32(bytes32 tSlot) internal pure returns (TBytes32 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `bytes32` in transient storage.\n    function tBytes32(uint256 tSlot) internal pure returns (TBytes32 storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TBytes32 storage ptr) internal view returns (bytes32 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TBytes32 storage ptr) internal view returns (bytes32 result) {\n        result = block.chainid == 1 ? get(ptr) : bytes32(_compat(ptr)._spacer);\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TBytes32 storage ptr, bytes32 value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, value)\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TBytes32 storage ptr, bytes32 value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        _compat(ptr)._spacer = uint256(value);\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TBytes32 storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TBytes32 storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     ADDRESS OPERATIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `address` in transient storage.\n    function tAddress(bytes32 tSlot) internal pure returns (TAddress storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `address` in transient storage.\n    function tAddress(uint256 tSlot) internal pure returns (TAddress storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TAddress storage ptr) internal view returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TAddress storage ptr) internal view returns (address result) {\n        result = block.chainid == 1 ? get(ptr) : address(uint160(_compat(ptr)._spacer));\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TAddress storage ptr, address value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, shr(96, shl(96, value)))\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TAddress storage ptr, address value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        _compat(ptr)._spacer = uint160(value);\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TAddress storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TAddress storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      BOOL OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `bool` in transient storage.\n    function tBool(bytes32 tSlot) internal pure returns (TBool storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `bool` in transient storage.\n    function tBool(uint256 tSlot) internal pure returns (TBool storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function get(TBool storage ptr) internal view returns (bool result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := tload(ptr.slot)\n        }\n    }\n\n    /// @dev Returns the value at transient `ptr`.\n    function getCompat(TBool storage ptr) internal view returns (bool result) {\n        result = block.chainid == 1 ? get(ptr) : _compat(ptr)._spacer != 0;\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TBool storage ptr, bool value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, iszero(iszero(value)))\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TBool storage ptr, bool value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            sstore(ptr.slot, iszero(iszero(value)))\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TBool storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TBool storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      BYTES OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a pointer to a `bytes` in transient storage.\n    function tBytes(bytes32 tSlot) internal pure returns (TBytes storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns a pointer to a `bytes` in transient storage.\n    function tBytes(uint256 tSlot) internal pure returns (TBytes storage ptr) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            ptr.slot := tSlot\n        }\n    }\n\n    /// @dev Returns the length of the bytes stored at transient `ptr`.\n    function length(TBytes storage ptr) internal view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(224, tload(ptr.slot))\n        }\n    }\n\n    /// @dev Returns the length of the bytes stored at transient `ptr`.\n    function lengthCompat(TBytes storage ptr) internal view returns (uint256 result) {\n        if (block.chainid == 1) return length(ptr);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(224, sload(ptr.slot))\n        }\n    }\n\n    /// @dev Returns the bytes stored at transient `ptr`.\n    function get(TBytes storage ptr) internal view returns (bytes memory result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := mload(0x40)\n            mstore(result, 0x00)\n            mstore(add(result, 0x1c), tload(ptr.slot)) // Length and first `0x1c` bytes.\n            let n := mload(result)\n            let e := add(add(result, 0x20), n)\n            if iszero(lt(n, 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let d := sub(keccak256(0x00, 0x20), result)\n                for { let o := add(result, 0x3c) } 1 {} {\n                    mstore(o, tload(add(o, d)))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n            mstore(e, 0) // Zeroize the slot after the string.\n            mstore(0x40, add(0x20, e)) // Allocate memory.\n        }\n    }\n\n    /// @dev Returns the bytes stored at transient `ptr`.\n    function getCompat(TBytes storage ptr) internal view returns (bytes memory result) {\n        if (block.chainid == 1) return get(ptr);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := mload(0x40)\n            mstore(result, 0x00)\n            mstore(add(result, 0x1c), sload(ptr.slot)) // Length and first `0x1c` bytes.\n            let n := mload(result)\n            let e := add(add(result, 0x20), n)\n            if iszero(lt(n, 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let d := sub(keccak256(0x00, 0x20), result)\n                for { let o := add(result, 0x3c) } 1 {} {\n                    mstore(o, sload(add(o, d)))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n            mstore(e, 0) // Zeroize the slot after the string.\n            mstore(0x40, add(0x20, e)) // Allocate memory.\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function set(TBytes storage ptr, bytes memory value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, mload(add(value, 0x1c)))\n            if iszero(lt(mload(value), 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let e := add(add(value, 0x20), mload(value))\n                let d := sub(keccak256(0x00, or(0x20, sub(0, shr(32, mload(value))))), value)\n                for { let o := add(value, 0x3c) } 1 {} {\n                    tstore(add(o, d), mload(o))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCompat(TBytes storage ptr, bytes memory value) internal {\n        if (block.chainid == 1) return set(ptr, value);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            sstore(ptr.slot, mload(add(value, 0x1c)))\n            if iszero(lt(mload(value), 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let e := add(add(value, 0x20), mload(value))\n                let d := sub(keccak256(0x00, or(0x20, sub(0, shr(32, mload(value))))), value)\n                for { let o := add(value, 0x3c) } 1 {} {\n                    sstore(add(o, d), mload(o))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCalldata(TBytes storage ptr, bytes calldata value) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, calldataload(sub(value.offset, 0x04)))\n            if iszero(lt(value.length, 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let e := add(value.offset, value.length)\n                // forgefmt: disable-next-item\n                let d := add(sub(keccak256(0x00, or(0x20, sub(0, shr(32, value.length)))),\n                    value.offset), 0x20)\n                for { let o := add(value.offset, 0x1c) } 1 {} {\n                    tstore(add(o, d), calldataload(o))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Sets the value at transient `ptr`.\n    function setCalldataCompat(TBytes storage ptr, bytes calldata value) internal {\n        if (block.chainid == 1) return setCalldata(ptr, value);\n        ptr = _compat(ptr);\n        /// @solidity memory-safe-assembly\n        assembly {\n            sstore(ptr.slot, calldataload(sub(value.offset, 0x04)))\n            if iszero(lt(value.length, 0x1d)) {\n                mstore(0x00, ptr.slot)\n                let e := add(value.offset, value.length)\n                // forgefmt: disable-next-item\n                let d := add(sub(keccak256(0x00, or(0x20, sub(0, shr(32, value.length)))),\n                    value.offset), 0x20)\n                for { let o := add(value.offset, 0x1c) } 1 {} {\n                    sstore(add(o, d), calldataload(o))\n                    o := add(o, 0x20)\n                    if iszero(lt(o, e)) { break }\n                }\n            }\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clear(TBytes storage ptr) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            tstore(ptr.slot, 0)\n        }\n    }\n\n    /// @dev Clears the value at transient `ptr`.\n    function clearCompat(TBytes storage ptr) internal {\n        if (block.chainid == 1) return clear(ptr);\n        _compat(ptr)._spacer = 0;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TUint256 storage ptr) private pure returns (TUint256 storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TInt256 storage ptr) private pure returns (TInt256 storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TBytes32 storage ptr) private pure returns (TBytes32 storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TAddress storage ptr) private pure returns (TAddress storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TBool storage ptr) private pure returns (TBool storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\n\n    /// @dev Returns a regular storage pointer used for compatibility.\n    function _compat(TBytes storage ptr) private pure returns (TBytes storage c) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _LIB_TRANSIENT_COMPAT_SLOT_SEED)\n            mstore(0x00, ptr.slot)\n            c.slot := keccak256(0x00, 0x24)\n        }\n    }\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 _INTIALIZED_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    /*                         OPERATIONS                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return a 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, _INTIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Guards an reinitialzer 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            version := and(version, 0xffffffffffffffff) // Clean upper bits.\n            let i := sload(s)\n            // If `initializing == 1 || initializedVersion >= version`.\n            if iszero(lt(and(i, 1), lt(shr(1, 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, shl(1, version)))\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Set `initializing` to 0, `initializedVersion` to `version`.\n            sstore(s, shl(1, version))\n            // Emit the {Initialized} event.\n            mstore(0x20, version)\n            log1(0x20, 0x20, _INTIALIZED_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 := shr(192, s) // Computed to save bytecode.\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, _INTIALIZED_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"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":0,"enabled":true},"evmVersion":"cancun","remappings":["ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/","forge-gas-snapshot/=lib/v4-core/lib/forge-gas-snapshot/src/","forge-std/=lib/forge-std/src/","hardhat/=lib/v4-core/node_modules/hardhat/","permit2/=lib/v4-periphery/lib/permit2/","@solmate/=lib/v4-core/lib/solmate/src/","@solady/=lib/solady/src/","@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/contracts/","lib/v4-core/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","lib/v4-periphery/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","lib/universal-router/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","@v4-periphery/=lib/v4-periphery/src/","@v4-periphery-test/=lib/v4-periphery/test/","@v4-core-test/=lib/v4-periphery/lib/v4-core/test/","@v4-core/=lib/v4-periphery/lib/v4-core/src/","@v3-periphery/=lib/v3-periphery/contracts/","@v3-core/=lib/v3-core/contracts/","@uniswap/v3-core/=lib/v3-core/","@universal-router/=lib/universal-router/contracts/","@uniswap/v2-core/contracts/interfaces/=src/interfaces/","@quoter/=lib/view-quoter-v4/src/","lib/v4-core/libraries/=lib/v4-periphery/lib/v4-core/libraries/","lib/v4-core/src/=lib/v4-periphery/lib/v4-core/src/","lib/view-quoter-v4/:@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/","@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/","createx/=lib/createx/src/","@ensdomains/=lib/v4-core/node_modules/@ensdomains/","@uniswap/v3-periphery/=lib/universal-router/lib/v3-periphery/","@uniswap/v4-periphery/=lib/universal-router/lib/v4-periphery/","dn404/=lib/dn404/","openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/","openzeppelin/=lib/createx/lib/openzeppelin-contracts/contracts/","solady/=lib/solady/src/","solmate/=lib/universal-router/lib/solmate/","universal-router/=lib/universal-router/","v3-core/=lib/v3-core/","v3-periphery/=lib/v3-periphery/contracts/","v4-core/=lib/v4-core/src/","v4-periphery/=lib/v4-periphery/","view-quoter-v4/=lib/view-quoter-v4/src/"]}},"stdJsonOutput":{"sources":{"src/types/Wad.sol":{"id":6},"src/tokens/DopplerERC20V1.sol":{"id":5},"lib/solady/src/auth/Ownable.sol":{"id":0},"lib/solady/src/tokens/ERC20.sol":{"id":1},"lib/solady/src/tokens/ERC20Votes.sol":{"id":2},"lib/solady/src/utils/LibTransient.sol":{"id":4},"lib/solady/src/utils/Initializable.sol":{"id":3}},"contracts":{"src/tokens/DopplerERC20V1.sol":{"DopplerERC20V1":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AllowanceOverflow","type":"error","inputs":[]},{"name":"AllowanceUnderflow","type":"error","inputs":[]},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"ArrayLengthsMismatch","type":"error","inputs":[]},{"name":"BalanceLimitExceeded","type":"error","inputs":[{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"BalanceLimitNotActive","type":"error","inputs":[]},{"name":"ERC5805CheckpointIndexOutOfBounds","type":"error","inputs":[]},{"name":"ERC5805CheckpointValueOverflow","type":"error","inputs":[]},{"name":"ERC5805CheckpointValueUnderflow","type":"error","inputs":[]},{"name":"ERC5805DelegateInvalidSignature","type":"error","inputs":[]},{"name":"ERC5805DelegateSignatureExpired","type":"error","inputs":[]},{"name":"ERC5805FutureLookup","type":"error","inputs":[]},{"name":"InsufficientAllowance","type":"error","inputs":[]},{"name":"InsufficientBalance","type":"error","inputs":[]},{"name":"InsufficientReleasableAmount","type":"error","inputs":[{"name":"available","type":"uint256","internalType":"uint256"},{"name":"requested","type":"uint256","internalType":"uint256"}]},{"name":"InvalidAllocation","type":"error","inputs":[{"name":"index","type":"uint256","internalType":"uint256"}]},{"name":"InvalidBalanceLimit","type":"error","inputs":[{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"InvalidBalanceLimitTimestamp","type":"error","inputs":[{"name":"specified","type":"uint256","internalType":"uint256"},{"name":"current","type":"uint256","internalType":"uint256"}]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"InvalidPermit","type":"error","inputs":[]},{"name":"InvalidSchedule","type":"error","inputs":[{"name":"scheduleId","type":"uint256","internalType":"uint256"}]},{"name":"MaxPreMintPerAddressExceeded","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"MaxTotalPreMintExceeded","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"MaxTotalVestedExceeded","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"limit","type":"uint256","internalType":"uint256"}]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"NoReleasableAmount","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"Permit2AllowanceIsFixedAtInfinity","type":"error","inputs":[]},{"name":"PermitExpired","type":"error","inputs":[]},{"name":"PoolAlreadyLocked","type":"error","inputs":[]},{"name":"PoolAlreadyUnlocked","type":"error","inputs":[]},{"name":"PoolLocked","type":"error","inputs":[]},{"name":"TotalSupplyOverflow","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"UnknownScheduleId","type":"error","inputs":[{"name":"scheduleId","type":"uint256","internalType":"uint256"}]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"BalanceLimitDisabled","type":"event","inputs":[{"name":"expired","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"DelegateChanged","type":"event","inputs":[{"name":"delegator","type":"address","indexed":true,"internalType":"address"},{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"DelegateVotesChanged","type":"event","inputs":[{"name":"delegate","type":"address","indexed":true,"internalType":"address"},{"name":"oldValue","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newValue","type":"uint256","indexed":false,"internalType":"uint256"}],"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":"TokensReleased","type":"event","inputs":[{"name":"beneficiary","type":"address","indexed":true,"internalType":"address"},{"name":"scheduleId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"UpdateTokenURI","type":"event","inputs":[{"name":"tokenURI","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"VestingAllocated","type":"event","inputs":[{"name":"beneficiary","type":"address","indexed":true,"internalType":"address"},{"name":"scheduleId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"VestingScheduleCreated","type":"event","inputs":[{"name":"scheduleId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"cliff","type":"uint64","indexed":false,"internalType":"uint64"},{"name":"duration","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"CLOCK_MODE","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"result","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceLimitEnd","type":"function","inputs":[],"outputs":[{"name":"","type":"uint48","internalType":"uint48"}],"stateMutability":"view"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"burn","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"checkpointAt","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"i","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"checkpointClock","type":"uint48","internalType":"uint48"},{"name":"checkpointValue","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"checkpointCount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"clock","type":"function","inputs":[],"outputs":[{"name":"result","type":"uint48","internalType":"uint48"}],"stateMutability":"view"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"computeAvailableVestedAmount","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"},{"name":"scheduleId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"computeAvailableVestedAmount","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"}],"outputs":[{"name":"total","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"controller","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"delegate","type":"function","inputs":[{"name":"delegatee","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"delegateBySig","type":"function","inputs":[{"name":"delegatee","type":"address","internalType":"address"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"expiry","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"delegates","type":"function","inputs":[{"name":"delegator","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"disableBalanceLimit","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"getPastVotes","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"timepoint","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getPastVotesTotalSupply","type":"function","inputs":[{"name":"timepoint","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getScheduleIdsOf","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"view"},{"name":"getVotes","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getVotesTotalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"name_","type":"string","internalType":"string"},{"name":"symbol_","type":"string","internalType":"string"},{"name":"initialSupply","type":"uint256","internalType":"uint256"},{"name":"recipient","type":"address","internalType":"address"},{"name":"owner_","type":"address","internalType":"address"},{"name":"schedules","type":"tuple[]","components":[{"name":"cliff","type":"uint64","internalType":"uint64"},{"name":"duration","type":"uint64","internalType":"uint64"}],"internalType":"struct VestingSchedule[]"},{"name":"beneficiaries","type":"address[]","internalType":"address[]"},{"name":"scheduleIds","type":"uint256[]","internalType":"uint256[]"},{"name":"amounts","type":"uint256[]","internalType":"uint256[]"},{"name":"tokenURI_","type":"string","internalType":"string"},{"name":"maxBalanceLimit_","type":"uint256","internalType":"uint256"},{"name":"balanceLimitEnd_","type":"uint48","internalType":"uint48"},{"name":"controller_","type":"address","internalType":"address"},{"name":"excludedFromBalanceLimit","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isBalanceLimitActive","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isExcludedFromBalanceLimit","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"excluded","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isPoolLocked","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"lockPool","type":"function","inputs":[{"name":"pool_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"maxBalanceLimit","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"nonces","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"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":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"pool","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"release","type":"function","inputs":[{"name":"scheduleId","type":"uint256","internalType":"uint256"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"release","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"releaseFor","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"releaseFor","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"},{"name":"scheduleId","type":"uint256","internalType":"uint256"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalAllocatedOf","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"unlockPool","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateTokenURI","type":"function","inputs":[{"name":"tokenURI_","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"vestedTotalAmount","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"vestingOf","type":"function","inputs":[{"name":"beneficiary","type":"address","internalType":"address"},{"name":"scheduleId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"totalAmount","type":"uint256","internalType":"uint256"},{"name":"releasedAmount","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"vestingScheduleCount","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"vestingSchedules","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"cliff","type":"uint64","internalType":"uint64"},{"name":"duration","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"name":"vestingStart","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.26+commit.8a97fa7a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AllowanceOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AllowanceUnderflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthsMismatch\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"limit\",\"type\":\"uint256\"}],\"name\":\"BalanceLimitExceeded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"BalanceLimitNotActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805CheckpointIndexOutOfBounds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805CheckpointValueOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805CheckpointValueUnderflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805DelegateInvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805DelegateSignatureExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805FutureLookup\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"available\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requested\",\"type\":\"uint256\"}],\"name\":\"InsufficientReleasableAmount\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"InvalidAllocation\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"limit\",\"type\":\"uint256\"}],\"name\":\"InvalidBalanceLimit\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"specified\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"current\",\"type\":\"uint256\"}],\"name\":\"InvalidBalanceLimitTimestamp\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInitialization\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidPermit\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"}],\"name\":\"InvalidSchedule\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"limit\",\"type\":\"uint256\"}],\"name\":\"MaxPreMintPerAddressExceeded\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"limit\",\"type\":\"uint256\"}],\"name\":\"MaxTotalPreMintExceeded\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"limit\",\"type\":\"uint256\"}],\"name\":\"MaxTotalVestedExceeded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewOwnerIsZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoHandoverRequest\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoReleasableAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotInitializing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Permit2AllowanceIsFixedAtInfinity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PermitExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PoolAlreadyLocked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PoolAlreadyUnlocked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PoolLocked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TotalSupplyOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"}],\"name\":\"UnknownScheduleId\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"expired\",\"type\":\"bool\"}],\"name\":\"BalanceLimitDisabled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"delegator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"DelegateChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"delegate\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldValue\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newValue\",\"type\":\"uint256\"}],\"name\":\"DelegateVotesChanged\",\"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\":\"beneficiary\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"TokensReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"tokenURI\",\"type\":\"string\"}],\"name\":\"UpdateTokenURI\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"VestingAllocated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"cliff\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"duration\",\"type\":\"uint64\"}],\"name\":\"VestingScheduleCreated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CLOCK_MODE\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"result\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"balanceLimitEnd\",\"outputs\":[{\"internalType\":\"uint48\",\"name\":\"\",\"type\":\"uint48\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"cancelOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"checkpointAt\",\"outputs\":[{\"internalType\":\"uint48\",\"name\":\"checkpointClock\",\"type\":\"uint48\"},{\"internalType\":\"uint256\",\"name\":\"checkpointValue\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"checkpointCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"clock\",\"outputs\":[{\"internalType\":\"uint48\",\"name\":\"result\",\"type\":\"uint48\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"completeOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"}],\"name\":\"computeAvailableVestedAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"}],\"name\":\"computeAvailableVestedAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"total\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"controller\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"delegatee\",\"type\":\"address\"}],\"name\":\"delegate\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"delegatee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiry\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"delegateBySig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"delegator\",\"type\":\"address\"}],\"name\":\"delegates\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"result\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"disableBalanceLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"timepoint\",\"type\":\"uint256\"}],\"name\":\"getPastVotes\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"timepoint\",\"type\":\"uint256\"}],\"name\":\"getPastVotesTotalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"}],\"name\":\"getScheduleIdsOf\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getVotes\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getVotesTotalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"initialSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"owner_\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint64\",\"name\":\"cliff\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"duration\",\"type\":\"uint64\"}],\"internalType\":\"struct VestingSchedule[]\",\"name\":\"schedules\",\"type\":\"tuple[]\"},{\"internalType\":\"address[]\",\"name\":\"beneficiaries\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"scheduleIds\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"tokenURI_\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"maxBalanceLimit_\",\"type\":\"uint256\"},{\"internalType\":\"uint48\",\"name\":\"balanceLimitEnd_\",\"type\":\"uint48\"},{\"internalType\":\"address\",\"name\":\"controller_\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"excludedFromBalanceLimit\",\"type\":\"address[]\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isBalanceLimitActive\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isExcludedFromBalanceLimit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"excluded\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isPoolLocked\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pool_\",\"type\":\"address\"}],\"name\":\"lockPool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxBalanceLimit\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"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\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pool\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"release\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"release\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"releaseFor\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"releaseFor\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"requestOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"}],\"name\":\"totalAllocatedOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unlockPool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"tokenURI_\",\"type\":\"string\"}],\"name\":\"updateTokenURI\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vestedTotalAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scheduleId\",\"type\":\"uint256\"}],\"name\":\"vestingOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"totalAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"releasedAmount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vestingScheduleCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"vestingSchedules\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"cliff\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"duration\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vestingStart\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Whetstone Research\",\"custom:security-contact\":\"security@whetstone.cc\",\"details\":\"This contract is designed to be cloned using the ERC1167 minimal proxy pattern\",\"errors\":{\"AllowanceOverflow()\":[{\"details\":\"The allowance has overflowed.\"}],\"AllowanceUnderflow()\":[{\"details\":\"The allowance has underflowed.\"}],\"AlreadyInitialized()\":[{\"details\":\"Cannot double-initialize.\"}],\"ArrayLengthsMismatch()\":[{\"details\":\"Thrown when two arrays have different lengths\"}],\"BalanceLimitExceeded(uint256,uint256)\":[{\"details\":\"Thrown when an address's balance exceeds the balance limit\"}],\"BalanceLimitNotActive()\":[{\"details\":\"Thrown when the balance limit is not active\"}],\"ERC5805CheckpointIndexOutOfBounds()\":[{\"details\":\"Out-of-bounds access for the checkpoints.\"}],\"ERC5805CheckpointValueOverflow()\":[{\"details\":\"Arithmetic overflow when pushing a new checkpoint.\"}],\"ERC5805CheckpointValueUnderflow()\":[{\"details\":\"Arithmetic underflow when pushing a new checkpoint.\"}],\"ERC5805DelegateInvalidSignature()\":[{\"details\":\"The ERC5805 signature to set a delegate is invalid.\"}],\"ERC5805DelegateSignatureExpired()\":[{\"details\":\"The ERC5805 signature to set a delegate has expired.\"}],\"ERC5805FutureLookup()\":[{\"details\":\"The timepoint is in the future.\"}],\"InsufficientAllowance()\":[{\"details\":\"Insufficient allowance.\"}],\"InsufficientBalance()\":[{\"details\":\"Insufficient balance.\"}],\"InsufficientReleasableAmount(uint256,uint256)\":[{\"details\":\"Thrown when the requested amount is greater than the available amount\"}],\"InvalidAllocation(uint256)\":[{\"details\":\"Thrown when an allocation is invalid (zero address or zero amount)\"}],\"InvalidBalanceLimit(uint256)\":[{\"details\":\"Thrown when the specified balance limit wad is invalid\"}],\"InvalidBalanceLimitTimestamp(uint256,uint256)\":[{\"details\":\"Thrown when the specified balance limit timestamp is in the past\"}],\"InvalidInitialization()\":[{\"details\":\"The contract is already initialized.\"}],\"InvalidPermit()\":[{\"details\":\"The permit is invalid.\"}],\"InvalidSchedule(uint256)\":[{\"details\":\"Thrown when a schedule is invalid (violates duration/cliff constraints)\"}],\"MaxPreMintPerAddressExceeded(uint256,uint256)\":[{\"details\":\"Thrown when trying to premint more than the maximum allowed per address\"}],\"MaxTotalPreMintExceeded(uint256,uint256)\":[{\"details\":\"Thrown when trying to premint more than the maximum allowed in total\"}],\"MaxTotalVestedExceeded(uint256,uint256)\":[{\"details\":\"Thrown when trying to mint more than the maximum allowed in total\"}],\"NewOwnerIsZeroAddress()\":[{\"details\":\"The `newOwner` cannot be the zero address.\"}],\"NoHandoverRequest()\":[{\"details\":\"The `pendingOwner` does not have a valid handover request.\"}],\"NoReleasableAmount()\":[{\"details\":\"Thrown when there is no releasable amount\"}],\"NotInitializing()\":[{\"details\":\"The contract is not initializing.\"}],\"Permit2AllowanceIsFixedAtInfinity()\":[{\"details\":\"The allowance of Permit2 is fixed at infinity.\"}],\"PermitExpired()\":[{\"details\":\"The permit has expired.\"}],\"PoolAlreadyLocked()\":[{\"details\":\"Thrown when trying to lock the pool while it is already locked\"}],\"PoolAlreadyUnlocked()\":[{\"details\":\"Thrown when trying to unlock the pool while it is already unlocked\"}],\"PoolLocked()\":[{\"details\":\"Thrown when trying to transfer tokens into the pool while it is locked\"}],\"TotalSupplyOverflow()\":[{\"details\":\"The total supply has overflowed.\"}],\"Unauthorized()\":[{\"details\":\"The caller is not authorized to call the function.\"}],\"UnknownScheduleId(uint256)\":[{\"details\":\"Thrown when the schedule ID is out of range\"}]},\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when `amount` tokens is approved by `owner` to be used by `spender`.\"},\"DelegateChanged(address,address,address)\":{\"details\":\"The delegate of `delegator` is changed from `from` to `to`.\"},\"DelegateVotesChanged(address,uint256,uint256)\":{\"details\":\"The votes balance of `delegate` is changed from `oldValue` to `newValue`.\"},\"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.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `amount` tokens is transferred from `from` to `to`.\"}},\"kind\":\"dev\",\"methods\":{\"CLOCK_MODE()\":{\"details\":\"Returns the clock mode.\"},\"DOMAIN_SEPARATOR()\":{\"details\":\"Returns the EIP-712 domain separator for the EIP-2612 permit.\"},\"allowance(address,address)\":{\"details\":\"Returns the amount of tokens that `spender` can spend on behalf of `owner`.\"},\"approve(address,uint256)\":{\"details\":\"Sets `amount` as the allowance of `spender` over the caller's tokens. Emits a {Approval} event.\"},\"balanceOf(address)\":{\"details\":\"Returns the amount of tokens owned by `owner`.\"},\"burn(uint256)\":{\"params\":{\"amount\":\"Amount of tokens to burn\"}},\"cancelOwnershipHandover()\":{\"details\":\"Cancels the two-step ownership handover to the caller, if any.\"},\"checkpointAt(address,uint256)\":{\"details\":\"Returns the voting checkpoint for `account` at index `i`.\"},\"checkpointCount(address)\":{\"details\":\"Returns the number of checkpoints for `account`.\"},\"clock()\":{\"details\":\"Retusn the current clock.\"},\"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`.\"},\"computeAvailableVestedAmount(address)\":{\"params\":{\"beneficiary\":\"Beneficiary address\"},\"returns\":{\"total\":\"Total amount available to release\"}},\"computeAvailableVestedAmount(address,uint256)\":{\"params\":{\"beneficiary\":\"Beneficiary address\",\"scheduleId\":\"Schedule ID\"},\"returns\":{\"_0\":\"Amount available to release\"}},\"decimals()\":{\"details\":\"Returns the decimals places of the token.\"},\"delegate(address)\":{\"details\":\"Set the voting delegate of the caller to `delegatee`.\"},\"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)\":{\"details\":\"Sets the voting delegate of the signature signer to `delegatee`.\"},\"delegates(address)\":{\"details\":\"Returns the current voting delegate of `delegator`.\"},\"disableBalanceLimit()\":{\"details\":\"Only callable by the controller, which is set during initialization      If the controller was not set, the balance limit cannot be disabled early\"},\"getPastVotes(address,uint256)\":{\"details\":\"Returns the latest amount of voting units `account` has before `timepoint`.\"},\"getPastVotesTotalSupply(uint256)\":{\"details\":\"Returns the latest amount of total voting units before `timepoint`.\"},\"getScheduleIdsOf(address)\":{\"params\":{\"beneficiary\":\"Beneficiary address\"},\"returns\":{\"_0\":\"Array of schedule IDs\"}},\"getVotes(address)\":{\"details\":\"Returns the latest amount of voting units for `account`.\"},\"getVotesTotalSupply()\":{\"details\":\"Returns the latest amount of total voting units.\"},\"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])\":{\"params\":{\"amounts\":\"Array of amounts for each allocation\",\"balanceLimitEnd_\":\"Balance limit end timestamp\",\"beneficiaries\":\"Array of beneficiary addresses for allocations\",\"controller_\":\"Controller address (optional, excluding it prevents disabling the balance limit earlier)\",\"excludedFromBalanceLimit\":\"Array of addresses to exclude from the balance limit.                                 This should include initializers, migrators, Uniswap PoolManager, treasury, etc.\",\"initialSupply\":\"Initial supply of the token\",\"maxBalanceLimit_\":\"Maximum balance limit\",\"name_\":\"Name of the token\",\"owner_\":\"Address receiving the ownership of the token\",\"recipient\":\"Address receiving the non-vested initial supply\",\"scheduleIds\":\"Array of schedule IDs corresponding to each allocation\",\"schedules\":\"Array of vesting schedules\",\"symbol_\":\"Symbol of the token\",\"tokenURI_\":\"Uniform Resource Identifier (URI)\"}},\"lockPool(address)\":{\"params\":{\"pool_\":\"Address of the pool to lock\"}},\"name()\":{\"details\":\"Returns the name of the token.\"},\"nonces(address)\":{\"details\":\"Returns the current nonce for `owner`. This value is used to compute the signature for EIP-2612 permit.\"},\"owner()\":{\"details\":\"Returns the owner of the contract.\"},\"ownershipHandoverExpiresAt(address)\":{\"details\":\"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\"},\"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)\":{\"details\":\"Sets `value` as the allowance of `spender` over the tokens of `owner`, authorized by a signed approval by `owner`. Emits a {Approval} event.\"},\"release(uint256)\":{\"details\":\"Use 0 for `amount` to release total available amount\",\"params\":{\"amount\":\"Amount of tokens to release\"}},\"release(uint256,uint256)\":{\"details\":\"Use 0 for `amount` to release total available amount\",\"params\":{\"amount\":\"Amount of tokens to release\",\"scheduleId\":\"Schedule ID to release from\"}},\"releaseFor(address,uint256)\":{\"details\":\"Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount\",\"params\":{\"amount\":\"Amount of tokens to release\",\"beneficiary\":\"Beneficiary address\"}},\"releaseFor(address,uint256,uint256)\":{\"details\":\"Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount\",\"params\":{\"amount\":\"Amount of tokens to release\",\"beneficiary\":\"Bneficiary address\",\"scheduleId\":\"Schedule ID to release from\"}},\"renounceOwnership()\":{\"details\":\"Allows the owner to renounce their ownership.\"},\"requestOwnershipHandover()\":{\"details\":\"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token.\"},\"totalSupply()\":{\"details\":\"Returns the amount of tokens in existence.\"},\"transfer(address,uint256)\":{\"details\":\"Transfer `amount` tokens from the caller to `to`. Requirements: - `from` must at least have `amount`. Emits a {Transfer} event.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"Transfers `amount` tokens from `from` to `to`. Note: Does not update the allowance if it is the maximum uint256 value. Requirements: - `from` must at least have `amount`. - The caller must have at least `amount` of allowance to transfer the tokens of `from`. Emits a {Transfer} event.\"},\"transferOwnership(address)\":{\"details\":\"Allows the owner to transfer the ownership to `newOwner`.\"},\"updateTokenURI(string)\":{\"params\":{\"tokenURI_\":\"New token Uniform Resource Identifier (URI)\"}}},\"stateVariables\":{\"_name\":{\"details\":\"Name of the token\"},\"_symbol\":{\"details\":\"Symbol of the token\"}},\"title\":\"DopplerERC20 V1.0.0\",\"version\":1},\"userdoc\":{\"events\":{\"BalanceLimitDisabled(bool)\":{\"notice\":\"Emitted when the balance limit is disabled\"},\"TokensReleased(address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are released to a beneficiary\"},\"UpdateTokenURI(string)\":{\"notice\":\"Emitted when the token URI is updated\"},\"VestingAllocated(address,uint256,uint256)\":{\"notice\":\"Emitted when tokens are allocated to a beneficiary under a schedule\"},\"VestingScheduleCreated(uint256,uint64,uint64)\":{\"notice\":\"Emitted when a new vesting schedule is created\"}},\"kind\":\"user\",\"methods\":{\"balanceLimitEnd()\":{\"notice\":\"Balance limit end timestamp (in seconds)\"},\"burn(uint256)\":{\"notice\":\"Burns `amount` of tokens from the caller's balance\"},\"computeAvailableVestedAmount(address)\":{\"notice\":\"Computes the total available vested amount for a beneficiary across all schedules\"},\"computeAvailableVestedAmount(address,uint256)\":{\"notice\":\"Computes the available vested amount for a beneficiary under a specific schedule\"},\"controller()\":{\"notice\":\"Controller address (can disable the balance limit)\"},\"disableBalanceLimit()\":{\"notice\":\"Permanently disables the balance limit\"},\"getScheduleIdsOf(address)\":{\"notice\":\"Returns the list of schedule IDs for a beneficiary\"},\"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])\":{\"notice\":\"Initializes the token with the given parameters\"},\"isBalanceLimitActive()\":{\"notice\":\"Whether the balance limit is active or not\"},\"isExcludedFromBalanceLimit(address)\":{\"notice\":\"Whether an address is excluded from the balance limit\"},\"isPoolLocked()\":{\"notice\":\"Whether the pool can receive tokens (unlocked) or not\"},\"lockPool(address)\":{\"notice\":\"Locks the pool, preventing it from receiving tokens, and excludes it from the balance limit\"},\"maxBalanceLimit()\":{\"notice\":\"Maximum balance limit\"},\"pool()\":{\"notice\":\"Address of the liquidity pool\"},\"release(uint256)\":{\"notice\":\"Releases all available vested tokens across all schedules for the caller\"},\"release(uint256,uint256)\":{\"notice\":\"Releases available vested tokens for a specific schedule\"},\"releaseFor(address,uint256)\":{\"notice\":\"Releases all available vested tokens for a beneficiary across all schedules\"},\"releaseFor(address,uint256,uint256)\":{\"notice\":\"Releases available vested tokens for a beneficiary under a specific schedule\"},\"tokenURI()\":{\"notice\":\"Uniform Resource Identifier (URI)\"},\"totalAllocatedOf(address)\":{\"notice\":\"Total allocated amount per beneficiary (for cap enforcement)\"},\"unlockPool()\":{\"notice\":\"Unlocks the pool, allowing it to receive tokens\"},\"updateTokenURI(string)\":{\"notice\":\"Updates the token Uniform Resource Identifier (URI)\"},\"vestedTotalAmount()\":{\"notice\":\"Total amount of vested tokens across all beneficiaries and schedules\"},\"vestingOf(address,uint256)\":{\"notice\":\"Vesting data for each (beneficiary, scheduleId) pair\"},\"vestingScheduleCount()\":{\"notice\":\"Returns the number of vesting schedules\"},\"vestingSchedules(uint256)\":{\"notice\":\"Array of vesting schedules (scheduleId = index)\"},\"vestingStart()\":{\"notice\":\"Timestamp of the start of all vesting schedules\"}},\"notice\":\"Clonable ERC20 token with multi-schedule vesting, pool lock, votes, max balance limit, and Permit2 support\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/tokens/DopplerERC20V1.sol\":\"DopplerERC20V1\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"appendCBOR\":false,\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":0},\"remappings\":[\":@ensdomains/=lib/v4-core/node_modules/@ensdomains/\",\":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/contracts/\",\":@quoter/=lib/view-quoter-v4/src/\",\":@solady/=lib/solady/src/\",\":@solmate/=lib/v4-core/lib/solmate/src/\",\":@uniswap/v2-core/contracts/interfaces/=src/interfaces/\",\":@uniswap/v3-core/=lib/v3-core/\",\":@uniswap/v3-periphery/=lib/universal-router/lib/v3-periphery/\",\":@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/\",\":@uniswap/v4-periphery/=lib/universal-router/lib/v4-periphery/\",\":@universal-router/=lib/universal-router/contracts/\",\":@v3-core/=lib/v3-core/contracts/\",\":@v3-periphery/=lib/v3-periphery/contracts/\",\":@v4-core-test/=lib/v4-periphery/lib/v4-core/test/\",\":@v4-core/=lib/v4-periphery/lib/v4-core/src/\",\":@v4-periphery-test/=lib/v4-periphery/test/\",\":@v4-periphery/=lib/v4-periphery/src/\",\":createx/=lib/createx/src/\",\":dn404/=lib/dn404/\",\":ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-gas-snapshot/=lib/v4-core/lib/forge-gas-snapshot/src/\",\":forge-std/=lib/forge-std/src/\",\":hardhat/=lib/v4-core/node_modules/hardhat/\",\":lib/v4-core/libraries/=lib/v4-periphery/lib/v4-core/libraries/\",\":lib/v4-core/src/=lib/v4-periphery/lib/v4-core/src/\",\":openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/\",\":openzeppelin/=lib/createx/lib/openzeppelin-contracts/contracts/\",\":permit2/=lib/v4-periphery/lib/permit2/\",\":solady/=lib/solady/src/\",\":solmate/=lib/universal-router/lib/solmate/\",\":universal-router/=lib/universal-router/\",\":v3-core/=lib/v3-core/\",\":v3-periphery/=lib/v3-periphery/contracts/\",\":v4-core/=lib/v4-core/src/\",\":v4-periphery/=lib/v4-periphery/\",\":view-quoter-v4/=lib/view-quoter-v4/src/\",\"lib/universal-router/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/\",\"lib/v4-core/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/\",\"lib/v4-periphery/:@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/\",\"lib/view-quoter-v4/:@uniswap/v4-core/=lib/v4-periphery/lib/v4-core/\"],\"viaIR\":true},\"sources\":{\"lib/solady/src/auth/Ownable.sol\":{\"keccak256\":\"0xc208cdd9de02bbf4b5edad18b88e23a2be7ff56d2287d5649329dc7cda64b9a3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e8fba079cc7230c617f7493a2e97873f88e59a53a5018fcb2e2b6ac42d8aa5a3\",\"dweb:/ipfs/QmTXg8GSt8hsK2cZhbPFrund1mrwVdkLQmEPoQaFy4fhjs\"]},\"lib/solady/src/tokens/ERC20.sol\":{\"keccak256\":\"0x1c3cdf5158b29b16ba2d2c7ff1f6d4304754605441257e198b46803f0fa9df1a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6ed3d15fd372495ff76439878fb5e007ae0b39da3ce3d9fd877ee8147647bb2\",\"dweb:/ipfs/QmZ1zC91VhPHMXAdcY8SahJMwDsC2B5q9uXFF16R5eHmkV\"]},\"lib/solady/src/tokens/ERC20Votes.sol\":{\"keccak256\":\"0x070ca968051573401964700c7c903d3106d46d8db1c33a394c20e2cf21e61306\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5de163eb6cea2d453e80e93bb8b790ba5f45b554dcd16feb5825f0c8d4e1463d\",\"dweb:/ipfs/QmcfbzZv7TniFTnnY8bxbLsGHRboJybbisK4zHiwkeXjBD\"]},\"lib/solady/src/utils/Initializable.sol\":{\"keccak256\":\"0x039ac865df50f874528619e58f2bfaa665b6cec82647c711e515cb252a45a2ec\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1886c0e71f4861a23113f9d3eb5f6f00397c1d1bf0191f92534c177a79ac8559\",\"dweb:/ipfs/QmPLWU427MN9KHFg6DFkrYNutCDLdtNSQLaqmPqKcoPRLy\"]},\"lib/solady/src/utils/LibTransient.sol\":{\"keccak256\":\"0xd88aaa025471524c7cc93b7cf45318963bdea2c2bcb7c6c4064a96d3d97c2b64\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4891fab99ef22c149eb819492b245e4831497f8bd828171e892c284bd31921a9\",\"dweb:/ipfs/QmdsxhTsdNHEJNDR2QZb5NDK4oc4yxPJX42rpdHrB51dcv\"]},\"src/tokens/DopplerERC20V1.sol\":{\"keccak256\":\"0xbbd682cb5e84acbd957b99aedd53f4ee2ea7fe617588649b53ba96475007310a\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://5927ddcb9d51f61dff1076ddf5a207fcd1521353245bd7a98a502a581d24e7ed\",\"dweb:/ipfs/QmPwfupkXDg9zjgy5oP52VtXiHtLMC9rUVbrBMdJHUNgwF\"]},\"src/types/Wad.sol\":{\"keccak256\":\"0xef31939439d4fab5c019df2ab74badcd0093b0f7662188e5ff36bf28e529dc65\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1e81ea4d92568594c3bc8f8347a8264ee4b7bf4f517d0af89daf44a1e2166e32\",\"dweb:/ipfs/QmUNjcUB27BEGhUypiq8mmMwQwkLKu6okXXhTBT66k6qHk\"]}},\"version\":1}","userdoc":{"kind":"user","events":{"UpdateTokenURI(string)":{"notice":"Emitted when the token URI is updated"},"BalanceLimitDisabled(bool)":{"notice":"Emitted when the balance limit is disabled"},"TokensReleased(address,uint256,uint256)":{"notice":"Emitted when tokens are released to a beneficiary"},"VestingAllocated(address,uint256,uint256)":{"notice":"Emitted when tokens are allocated to a beneficiary under a schedule"},"VestingScheduleCreated(uint256,uint64,uint64)":{"notice":"Emitted when a new vesting schedule is created"}},"notice":"Clonable ERC20 token with multi-schedule vesting, pool lock, votes, max balance limit, and Permit2 support","methods":{"pool()":{"notice":"Address of the liquidity pool"},"tokenURI()":{"notice":"Uniform Resource Identifier (URI)"},"controller()":{"notice":"Controller address (can disable the balance limit)"},"unlockPool()":{"notice":"Unlocks the pool, allowing it to receive tokens"},"burn(uint256)":{"notice":"Burns `amount` of tokens from the caller's balance"},"isPoolLocked()":{"notice":"Whether the pool can receive tokens (unlocked) or not"},"vestingStart()":{"notice":"Timestamp of the start of all vesting schedules"},"release(uint256)":{"notice":"Releases all available vested tokens across all schedules for the caller"},"balanceLimitEnd()":{"notice":"Balance limit end timestamp (in seconds)"},"lockPool(address)":{"notice":"Locks the pool, preventing it from receiving tokens, and excludes it from the balance limit"},"maxBalanceLimit()":{"notice":"Maximum balance limit"},"vestedTotalAmount()":{"notice":"Total amount of vested tokens across all beneficiaries and schedules"},"disableBalanceLimit()":{"notice":"Permanently disables the balance limit"},"isBalanceLimitActive()":{"notice":"Whether the balance limit is active or not"},"updateTokenURI(string)":{"notice":"Updates the token Uniform Resource Identifier (URI)"},"vestingScheduleCount()":{"notice":"Returns the number of vesting schedules"},"release(uint256,uint256)":{"notice":"Releases available vested tokens for a specific schedule"},"getScheduleIdsOf(address)":{"notice":"Returns the list of schedule IDs for a beneficiary"},"totalAllocatedOf(address)":{"notice":"Total allocated amount per beneficiary (for cap enforcement)"},"vestingSchedules(uint256)":{"notice":"Array of vesting schedules (scheduleId = index)"},"vestingOf(address,uint256)":{"notice":"Vesting data for each (beneficiary, scheduleId) pair"},"releaseFor(address,uint256)":{"notice":"Releases all available vested tokens for a beneficiary across all schedules"},"isExcludedFromBalanceLimit(address)":{"notice":"Whether an address is excluded from the balance limit"},"releaseFor(address,uint256,uint256)":{"notice":"Releases available vested tokens for a beneficiary under a specific schedule"},"computeAvailableVestedAmount(address)":{"notice":"Computes the total available vested amount for a beneficiary across all schedules"},"computeAvailableVestedAmount(address,uint256)":{"notice":"Computes the available vested amount for a beneficiary under a specific schedule"},"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])":{"notice":"Initializes the token with the given parameters"}},"version":1},"devdoc":{"kind":"dev","title":"DopplerERC20 V1.0.0","author":"Whetstone Research","errors":{"PoolLocked()":[{"details":"Thrown when trying to transfer tokens into the pool while it is locked"}],"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"InvalidPermit()":[{"details":"The permit is invalid."}],"PermitExpired()":[{"details":"The permit has expired."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"AllowanceOverflow()":[{"details":"The allowance has overflowed."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"PoolAlreadyLocked()":[{"details":"Thrown when trying to lock the pool while it is already locked"}],"AllowanceUnderflow()":[{"details":"The allowance has underflowed."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"NoReleasableAmount()":[{"details":"Thrown when there is no releasable amount"}],"ERC5805FutureLookup()":[{"details":"The timepoint is in the future."}],"InsufficientBalance()":[{"details":"Insufficient balance."}],"PoolAlreadyUnlocked()":[{"details":"Thrown when trying to unlock the pool while it is already unlocked"}],"TotalSupplyOverflow()":[{"details":"The total supply has overflowed."}],"ArrayLengthsMismatch()":[{"details":"Thrown when two arrays have different lengths"}],"BalanceLimitNotActive()":[{"details":"Thrown when the balance limit is not active"}],"InsufficientAllowance()":[{"details":"Insufficient allowance."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"InvalidSchedule(uint256)":[{"details":"Thrown when a schedule is invalid (violates duration/cliff constraints)"}],"InvalidAllocation(uint256)":[{"details":"Thrown when an allocation is invalid (zero address or zero amount)"}],"UnknownScheduleId(uint256)":[{"details":"Thrown when the schedule ID is out of range"}],"InvalidBalanceLimit(uint256)":[{"details":"Thrown when the specified balance limit wad is invalid"}],"ERC5805CheckpointValueOverflow()":[{"details":"Arithmetic overflow when pushing a new checkpoint."}],"ERC5805CheckpointValueUnderflow()":[{"details":"Arithmetic underflow when pushing a new checkpoint."}],"ERC5805DelegateInvalidSignature()":[{"details":"The ERC5805 signature to set a delegate is invalid."}],"ERC5805DelegateSignatureExpired()":[{"details":"The ERC5805 signature to set a delegate has expired."}],"ERC5805CheckpointIndexOutOfBounds()":[{"details":"Out-of-bounds access for the checkpoints."}],"Permit2AllowanceIsFixedAtInfinity()":[{"details":"The allowance of Permit2 is fixed at infinity."}],"BalanceLimitExceeded(uint256,uint256)":[{"details":"Thrown when an address's balance exceeds the balance limit"}],"MaxTotalVestedExceeded(uint256,uint256)":[{"details":"Thrown when trying to mint more than the maximum allowed in total"}],"MaxTotalPreMintExceeded(uint256,uint256)":[{"details":"Thrown when trying to premint more than the maximum allowed in total"}],"InsufficientReleasableAmount(uint256,uint256)":[{"details":"Thrown when the requested amount is greater than the available amount"}],"InvalidBalanceLimitTimestamp(uint256,uint256)":[{"details":"Thrown when the specified balance limit timestamp is in the past"}],"MaxPreMintPerAddressExceeded(uint256,uint256)":[{"details":"Thrown when trying to premint more than the maximum allowed per address"}]},"events":{"Initialized(uint64)":{"details":"Triggered when the contract has been initialized."},"Approval(address,address,uint256)":{"details":"Emitted when `amount` tokens is approved by `owner` to be used by `spender`."},"Transfer(address,address,uint256)":{"details":"Emitted when `amount` tokens is transferred from `from` to `to`."},"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."},"DelegateChanged(address,address,address)":{"details":"The delegate of `delegator` is changed from `from` to `to`."},"DelegateVotesChanged(address,uint256,uint256)":{"details":"The votes balance of `delegate` is changed from `oldValue` to `newValue`."}},"details":"This contract is designed to be cloned using the ERC1167 minimal proxy pattern","methods":{"name()":{"details":"Returns the name of the token."},"clock()":{"details":"Retusn the current clock."},"owner()":{"details":"Returns the owner of the contract."},"symbol()":{"details":"Returns the symbol of the token."},"decimals()":{"details":"Returns the decimals places of the token."},"CLOCK_MODE()":{"details":"Returns the clock mode."},"burn(uint256)":{"params":{"amount":"Amount of tokens to burn"}},"totalSupply()":{"details":"Returns the amount of tokens in existence."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value is used to compute the signature for EIP-2612 permit."},"release(uint256)":{"params":{"amount":"Amount of tokens to release"},"details":"Use 0 for `amount` to release total available amount"},"delegate(address)":{"details":"Set the voting delegate of the caller to `delegatee`."},"getVotes(address)":{"details":"Returns the latest amount of voting units for `account`."},"lockPool(address)":{"params":{"pool_":"Address of the pool to lock"}},"DOMAIN_SEPARATOR()":{"details":"Returns the EIP-712 domain separator for the EIP-2612 permit."},"balanceOf(address)":{"details":"Returns the amount of tokens owned by `owner`."},"delegates(address)":{"details":"Returns the current voting delegate of `delegator`."},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"disableBalanceLimit()":{"details":"Only callable by the controller, which is set during initialization      If the controller was not set, the balance limit cannot be disabled early"},"getVotesTotalSupply()":{"details":"Returns the latest amount of total voting units."},"updateTokenURI(string)":{"params":{"tokenURI_":"New token Uniform Resource Identifier (URI)"}},"approve(address,uint256)":{"details":"Sets `amount` as the allowance of `spender` over the caller's tokens. Emits a {Approval} event."},"checkpointCount(address)":{"details":"Returns the number of checkpoints for `account`."},"release(uint256,uint256)":{"params":{"amount":"Amount of tokens to release","scheduleId":"Schedule ID to release from"},"details":"Use 0 for `amount` to release total available amount"},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"getScheduleIdsOf(address)":{"params":{"beneficiary":"Beneficiary address"},"returns":{"_0":"Array of schedule IDs"}},"transfer(address,uint256)":{"details":"Transfer `amount` tokens from the caller to `to`. Requirements: - `from` must at least have `amount`. Emits a {Transfer} event."},"allowance(address,address)":{"details":"Returns the amount of tokens that `spender` can spend on behalf of `owner`."},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"releaseFor(address,uint256)":{"params":{"amount":"Amount of tokens to release","beneficiary":"Beneficiary address"},"details":"Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount"},"checkpointAt(address,uint256)":{"details":"Returns the voting checkpoint for `account` at index `i`."},"getPastVotes(address,uint256)":{"details":"Returns the latest amount of voting units `account` has before `timepoint`."},"getPastVotesTotalSupply(uint256)":{"details":"Returns the latest amount of total voting units before `timepoint`."},"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`."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"releaseFor(address,uint256,uint256)":{"params":{"amount":"Amount of tokens to release","scheduleId":"Schedule ID to release from","beneficiary":"Bneficiary address"},"details":"Anyone can call; tokens always go to the beneficiary; use 0 for `amount` to release total available amount"},"computeAvailableVestedAmount(address)":{"params":{"beneficiary":"Beneficiary address"},"returns":{"total":"Total amount available to release"}},"transferFrom(address,address,uint256)":{"details":"Transfers `amount` tokens from `from` to `to`. Note: Does not update the allowance if it is the maximum uint256 value. Requirements: - `from` must at least have `amount`. - The caller must have at least `amount` of allowance to transfer the tokens of `from`. Emits a {Transfer} event."},"computeAvailableVestedAmount(address,uint256)":{"params":{"scheduleId":"Schedule ID","beneficiary":"Beneficiary address"},"returns":{"_0":"Amount available to release"}},"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets the voting delegate of the signature signer to `delegatee`."},"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets `value` as the allowance of `spender` over the tokens of `owner`, authorized by a signed approval by `owner`. Emits a {Approval} event."},"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])":{"params":{"name_":"Name of the token","owner_":"Address receiving the ownership of the token","amounts":"Array of amounts for each allocation","symbol_":"Symbol of the token","recipient":"Address receiving the non-vested initial supply","schedules":"Array of vesting schedules","tokenURI_":"Uniform Resource Identifier (URI)","controller_":"Controller address (optional, excluding it prevents disabling the balance limit earlier)","scheduleIds":"Array of schedule IDs corresponding to each allocation","beneficiaries":"Array of beneficiary addresses for allocations","initialSupply":"Initial supply of the token","balanceLimitEnd_":"Balance limit end timestamp","maxBalanceLimit_":"Maximum balance limit","excludedFromBalanceLimit":"Array of addresses to exclude from the balance limit.                                 This should include initializers, migrators, Uniswap PoolManager, treasury, etc."}}},"version":1,"stateVariables":{"_name":{"details":"Name of the token"},"_symbol":{"details":"Symbol of the token"}},"custom:security-contact":"security@whetstone.cc"},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint48":{"label":"uint48","encoding":"inplace","numberOfBytes":"6"},"t_uint64":{"label":"uint64","encoding":"inplace","numberOfBytes":"8"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_array(t_uint256)dyn_storage":{"base":"t_uint256","label":"uint256[]","encoding":"dynamic_array","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_struct(VestingData)2889_storage":{"label":"struct VestingData","members":[{"slot":"0","type":"t_uint256","astId":2886,"label":"totalAmount","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"1","type":"t_uint256","astId":2888,"label":"releasedAmount","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"}],"encoding":"inplace","numberOfBytes":"64"},"t_struct(VestingSchedule)2883_storage":{"label":"struct VestingSchedule","members":[{"slot":"0","type":"t_uint64","astId":2880,"label":"cliff","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"0","type":"t_uint64","astId":2882,"label":"duration","offset":8,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_array(t_uint256)dyn_storage)":{"key":"t_address","label":"mapping(address => uint256[])","value":"t_array(t_uint256)dyn_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_struct(VestingData)2889_storage)":{"key":"t_uint256","label":"mapping(uint256 => struct VestingData)","value":"t_struct(VestingData)2889_storage","encoding":"mapping","numberOfBytes":"32"},"t_array(t_struct(VestingSchedule)2883_storage)dyn_storage":{"base":"t_struct(VestingSchedule)2883_storage","label":"struct VestingSchedule[]","encoding":"dynamic_array","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_uint256,t_struct(VestingData)2889_storage))":{"key":"t_address","label":"mapping(address => mapping(uint256 => struct VestingData))","value":"t_mapping(t_uint256,t_struct(VestingData)2889_storage)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_string_storage","astId":2938,"label":"_name","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"1","type":"t_string_storage","astId":2941,"label":"_symbol","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"2","type":"t_string_storage","astId":2944,"label":"tokenURI","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"3","type":"t_uint256","astId":2947,"label":"vestingStart","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"4","type":"t_uint256","astId":2950,"label":"vestedTotalAmount","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"5","type":"t_address","astId":2953,"label":"controller","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"6","type":"t_address","astId":2956,"label":"pool","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"6","type":"t_bool","astId":2959,"label":"isPoolLocked","offset":20,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"6","type":"t_bool","astId":2962,"label":"isBalanceLimitActive","offset":21,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"6","type":"t_uint48","astId":2965,"label":"balanceLimitEnd","offset":22,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"7","type":"t_uint256","astId":2968,"label":"maxBalanceLimit","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"8","type":"t_array(t_struct(VestingSchedule)2883_storage)dyn_storage","astId":2973,"label":"vestingSchedules","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"9","type":"t_mapping(t_address,t_mapping(t_uint256,t_struct(VestingData)2889_storage))","astId":2981,"label":"vestingOf","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"10","type":"t_mapping(t_address,t_uint256)","astId":2986,"label":"totalAllocatedOf","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"11","type":"t_mapping(t_address,t_array(t_uint256)dyn_storage)","astId":2992,"label":"_scheduleIdsOf","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"},{"slot":"12","type":"t_mapping(t_address,t_bool)","astId":2997,"label":"isExcludedFromBalanceLimit","offset":0,"contract":"src/tokens/DopplerERC20V1.sol:DopplerERC20V1"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"4336:20209:5:-:0;;;;;;;-1:-1:-1;;6669:609:3;;;;;;2001:66;6669:609;-1:-1:-1;;;;;;6669:609:3;;;-1:-1:-1;4336:20209:5;;;;;;;6669:609:3;-1:-1:-1;;;;;;;6669:609:3;-1:-1:-1;;;;;6669:609:3;;;;;;;;;;;;-1:-1:-1;6669:609:3;;;;4336:20209:5;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"4336:20209:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;11885:237:0;;;4336:20209:5;11885:237:0;4336:20209:5;11885:237:0;;;;4336:20209:5;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;4899:25;4336:20209;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;:::i;:::-;;;;5726:63;4336:20209;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;8479:183;;;;;;8681:8;;;:::i;:::-;4336:20209:5;8479:183:0;;4336:20209:5;8479:183:0;4336:20209:5;8479:183:0;;4336:20209:5;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;10506:526;;;;4336:20209:5;10506:526:0;4336:20209:5;10506:526:0;;;;;;;;;4336:20209:5;11051:12:0;10506:526;;11051:12;:::i;10506:526::-;;4336:20209:5;10506:526:0;4336:20209:5;10506:526:0;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;:::i;:::-;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;15767:6;4336:20209;;:::i;:::-;;;;;;15767:6;;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;17958:337:1;;;;;;;;;;;;4336:20209:5;;:::i;:::-;;;;;;18495:24:1;18618:2753;;;;;;4336:20209:5;18618:2753:1;8363:339;;;;;;18618:2753;;;;;;4336:20209:5;18618:2753:1;4336:20209:5;;18618:2753:1;;;;;;-1:-1:-1;;;;;;;;;;;18618:2753:1;;4336:20209:5;18618:2753:1;;;;;;4336:20209:5;18618:2753:1;;;-1:-1:-1;;;;;;;;;;;18618:2753:1;;;4336:20209:5;18618:2753:1;;;;;;;4336:20209:5;18618:2753:1;;;;;;4336:20209:5;18618:2753:1;;;;;;;;;;;;;4336:20209:5;18618:2753:1;;;;;;;;;4336:20209:5;18618:2753:1;4336:20209:5;18618:2753:1;4336:20209:5;18618:2753:1;4336:20209:5;;;18618:2753:1;4336:20209:5;;;18618:2753:1;4336:20209:5;18618:2753:1;4336:20209:5;;;18618:2753:1;;;;;;;;;-1:-1:-1;;;;;;;;;;;18618:2753:1;4336:20209:5;18618:2753:1;;;;;;;;;4336:20209:5;18618:2753:1;;;;;;4336:20209:5;18618:2753:1;;4336:20209:5;18618:2753:1;4336:20209:5;18618:2753:1;;;;4336:20209:5;18618:2753:1;4336:20209:5;18618:2753:1;;17958:337;;4336:20209:5;17958:337:1;4336:20209:5;17958:337:1;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;:::i;:::-;;;;16916:14;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;18243:342:2;4336:20209:5;;18243:342:2;;;;;;;4336:20209:5;;;;;;18243:342:2;-1:-1:-1;;;;;18243:342:2;;;18883:1470;18243:342;;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5259:29;4336:20209;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5068:216:2;;;4336:20209:5;5068:216:2;;;;4336:20209:5;5068:216:2;4336:20209:5;10991:20:2;;;10987:54;;-1:-1:-1;;;18883:1470:2;5068:216;18883:1470;4336:20209:5;18883:1470:2;4336:20209:5;18883:1470:2;;;;;;;;;;;;4336:20209:5;18883:1470:2;8363:339:1;15179:154:2;18883:1470;;;;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;;18883:1470:2;;;;;;;;;;;;;;;4336:20209:5;;15179:154:2;4336:20209:5;;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;;15179:154:2;4336:20209:5;;18883:1470:2;;;;;;;;;;;;;10987:54;20520:116;4336:20209:5;20520:116:2;4336:20209:5;20520:116:2;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;7209:24:2;7332:1413;;;;;4336:20209:5;7332:1413:2;;;4336:20209:5;7332:1413:2;8363:339:1;;;;;7332:1413:2;;4336:20209:5;7332:1413:2;;4336:20209:5;7332:1413:2;4336:20209:5;7332:1413:2;4336:20209:5;;7332:1413:2;4336:20209:5;7332:1413:2;;4336:20209:5;7332:1413:2;-1:-1:-1;;;;;;;;;;;7332:1413:2;;4336:20209:5;7332:1413:2;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;7332:1413:2;;;;4336:20209:5;7332:1413:2;;;;4336:20209:5;7332:1413:2;;;4336:20209:5;7332:1413:2;;4336:20209:5;7332:1413:2;;;;4336:20209:5;7332:1413:2;4336:20209:5;7332:1413:2;4336:20209:5;7332:1413:2;4336:20209:5;;;7332:1413:2;4336:20209:5;;;7332:1413:2;4336:20209:5;;;;7332:1413:2;;;;;4336:20209:5;7332:1413:2;4336:20209:5;;7332:1413:2;;;17266:205:1;;;;;4336:20209:5;17266:205:1;4336:20209:5;17266:205:1;;;8759:22:2;8758:33;8754:255;;9069:9;16797:203:1;17266:205;;16797:203;;4336:20209:5;16797:203:1;4336:20209:5;17266:205:1;16797:203;;;4336:20209:5;16797:203:1;;;9069:9:2;:::i;8754:255::-;8859:140;4336:20209:5;8859:140:2;4336:20209:5;8859:140:2;;7332:1413;;4336:20209:5;7332:1413:2;4336:20209:5;7332:1413:2;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;16212:6;4336:20209;;:::i;:::-;;;16212:6;;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;9514:6:1;9498:10;;;9514:6;:::i;:::-;9574:1143;;;9498:10;4336:20209:5;9574:1143:1;4336:20209:5;9574:1143:1;;;;;;;;;;;;12442:6:2;9574:1143:1;;;;;4336:20209:5;9574:1143:1;4336:20209:5;9574:1143:1;;;;;;;;;4336:20209:5;9574:1143:1;;;;;9498:10;-1:-1:-1;;;;;;;;;;;4336:20209:5;9574:1143:1;;9498:10;12122:18:2;12118:128;;4336:20209:5;-1:-1:-1;;;;;4336:20209:5;;12259:16:2;12255:127;;4336:20209:5;12427:13:2;12410:15;9498:10:1;12410:15:2;:::i;:::-;12427:13;;:::i;:::-;12442:6;;:::i;:::-;4336:20209:5;;;;;;;12255:127:2;5068:216;;;4336:20209:5;5068:216:2;;;;12291:80;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12291:80:2;:::i;:::-;12255:127;;;;12118:128;5068:216;;;4336:20209:5;5068:216:2;;;;12156:79;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12156:79:2;:::i;:::-;12118:128;;;;9574:1143:1;;4336:20209:5;9574:1143:1;4336:20209:5;9574:1143:1;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;;;18243:342;;;;;;;;;;4336:20209:5;;;;;;;18243:342:2;;-1:-1:-1;;18243:342:2;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;4336:20209:5;;-1:-1:-1;;;;;4336:20209:5;;;;;14222:20;4336:20209;;:::i;:::-;;;;;;;;;;;;;;;;;;14257:25;4336:20209;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;;;;;;18883:1470:2;;;4336:20209:5;;;;;;;14222:20;4336:20209;;;;14257:25;;;;;:::i;:::-;;;;4336:20209;;;;;;;;;;;;;;;;14222:20;4336:20209;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;14257:25;4336:20209;;;;;;;;;;14222:20;4336:20209;;;;;;;18883:1470:2;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14222:20;4336:20209;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;22793:7;4336:20209;;;;:::i;:::-;;;;;22793:7;4336:20209;;;22793:7;;;;4336:20209;;;;;;;;;;;;;;:::i;:::-;;;;;22793:7;4336:20209;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;;;;22793:7;4336:20209;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;;-1:-1:-1;;4336:20209:5;;;;5068:216:2;;;4336:20209:5;5068:216:2;;;;4336:20209:5;;;;5068:216:2;4336:20209:5;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;6136:10;4336:20209;-1:-1:-1;;;;;4336:20209:5;6122:10;:24;4336:20209;;13115:20;4336:20209;;;;;;;;;-1:-1:-1;;;;4336:20209:5;13115:20;4336:20209;;;;;;-1:-1:-1;;;;;;;;;;;13214:27:5;4336:20209;;13214:27;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;11523:61:0;4336:20209:5;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;12478:70:0;;:::i;:::-;12487:12:5;4336:20209;;;;;;;;;-1:-1:-1;;;;4336:20209:5;12487:12;4336:20209;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;;;;10069:510;;;;;;;;;;;4336:20209:5;10069:510:2;;;;;;;;;;;;;;4336:20209:5;;;;10069:510:2;;;4336:20209:5;;;;;;;10069:510:2;;;;;;;;;;4336:20209:5;10069:510:2;4336:20209:5;10069:510:2;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;-1:-1:-1;;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;:::i;:::-;2001:66:3;;;3207:622;;;;;;;;;;4336:20209:5;6813:405:0;;;;5710:347;;4336:20209:5;-1:-1:-1;;;;;;;;;;;5710:347:0;;;4336:20209:5;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;;4336:20209:5;3207:622:3;4336:20209:5;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;;4336:20209:5;3207:622:3;4336:20209:5;;;;;;;;7998:15;3207:622:3;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;8023:20;4336:20209;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;;4336:20209:5;3207:622:3;4336:20209:5;;;;;8023:20;4336:20209;;8058:20;;;;:44;;;4336:20209;8054:810;;4336:20209;;;;;;;;;;;;;8984:38;;:76;;;4336:20209;;;;;;9193:9;4336:20209;9204:19;;;;;;2387:9;;;;;;;;;;;;;;;;4336:20209;;146:4:6;;;;;4336:20209:5;;146:4:6;;;9950:20:5;;;;;;11312:31;;;;;;;;;2524:9;;11418:29;;;;2524:9;;4336:20209;11685:28;4336:20209;;;11685:28;4336:20209;;;11582:16;11578:81;;11685:28;:::i;:::-;;;:::i;:::-;3892:296:3;;4336:20209:5;3892:296:3;8023:20:5;3892:296:3;;4336:20209:5;;3892:296:3;;4336:20209:5;3892:296:3;;4336:20209:5;11578:81;11635:12;11628:4;;11635:12;:::i;:::-;11685:28;:::i;2524:9::-;;;;;;4336:20209;2524:9;4336:20209;;;;;;2524:9;;;;;;4336:20209;2524:9;4336:20209;;;;;;2524:9;9972:3;8363:339:1;;;;;;;;;;;10013:16:5;;;;:::i;:::-;4336:20209;;10064:14;;;;;:::i;:::-;4336:20209;10109:10;;;;:::i;:::-;4336:20209;10177:25;;;;:39;;;9972:3;2524:9;;;10253:68;10261:28;;;;10253:68;:::i;:::-;4336:20209;;;10399:16;4336:20209;;;;;10399:39;4336:20209;;;10399:39;:::i;:::-;4336:20209;;;;;10399:16;4336:20209;;;;;;10545:38;;;2524:9;;4336:20209;;;;10762:9;4336:20209;;;;;;;;;;;;;10762:56;4336:20209;;;10762:56;:::i;:::-;4336:20209;;;;;10832:26;4336:20209;;;;;;;;;;;;;;19359:47;;;;;:::i;:::-;17646:58:4;10952:47:5;10948:194;;9972:3;4336:20209;11156:22;11197:49;11156:22;4336:20209;11156:22;;:::i;:::-;4336:20209;;;;;;11197:49;4336:20209;9939:9;;;;;;;10948:194;19548:47;4336:20209;19548:47;;;;:::i;:::-;18084:72:4;4336:20209:5;;;;11083:14;4336:20209;;;;;2524:9;;4336:20209;;-1:-1:-1;;;2524:9:5;;;;;4336:20209;2524:9;;;;;4336:20209;;;;;;;;;;;;;;;;;;10948:194;;4336:20209;;;;;;;;;;;;2524:9;;;;;;4336:20209;2524:9;4336:20209;;;;;;2524:9;;;;;;4336:20209;2524:9;4336:20209;;;;2524:9;10177:39;10206:10;;;;10177:39;;2387:9;4336:20209;;;;;;;;;;;9225:3;9271:12;;;;:::i;:::-;;4336:20209;9440:10;;4336:20209;;9271:12;;9440:10;-1:-1:-1;;;;;4336:20209:5;9440:15;;;:53;;;;9225:3;9439:80;;;9225:3;2653:6;;;;9567:16;2653:6;-1:-1:-1;;;2653:6:5;;;;;;4336:20209;2653:6;;;9567:16;2653:6;;:::i;:::-;;;;;;4336:20209;2653:6;;4336:20209;;-1:-1:-1;;;;;;;4336:20209:5;2653:6;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;-1:-1:-1;;;;;;2653:6:5;;;;;;;;;4336:20209;;-1:-1:-1;;4336:20209:5;;9610:46;;4336:20209;;9610:46;;4336:20209;;;;9610:46;:::i;:::-;;;;4336:20209;9193:9;;2653:6;4336:20209;;;;;;;;;;;2653:6;;;;;4336:20209;2653:6;4336:20209;;;;2653:6;9439:80;4336:20209;;-1:-1:-1;;;;;4336:20209:5;9498:21;;;-1:-1:-1;9439:80:5;;;9440:53;2653:6;9459:34;;;;-1:-1:-1;9440:53:5;;4336:20209;;;;;;;;;8984:76;4336:20209;;;9026:34;;8984:76;;8054:810;8126:20;;;:56;;;8054:810;4336:20209;;;7998:15;8244:34;;4336:20209;;;-1:-1:-1;8359:34:5;4336:20209;;;;8455:24;4336:20209;;-1:-1:-1;;;;;;4336:20209:5;;;;;;;-1:-1:-1;;;;;;;;4336:20209:5;;;;;;;;-1:-1:-1;;;4336:20209:5;;;;;-1:-1:-1;;;4336:20209:5;;;-1:-1:-1;4336:20209:5;;;8534:26;4336:20209;;;;;;;;-1:-1:-1;;4336:20209:5;;;8363:339:1;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;8734:18;;;;;;8054:810;;;;;;8754:3;4336:20209;;-1:-1:-1;;;;;8804:27:5;8363:339:1;8804:27:5;;:::i;:::-;4336:20209;;;;8534:26;4336:20209;;;;;;;;;;;;;;;8723:9;;4336:20209;;;;;;;;7998:15;4336:20209;;;;;;;;;;;;;;;;;8126:56;8150:32;;;;8126:56;;8058:44;8082:20;;;;8058:44;;4336:20209;;;;-1:-1:-1;4336:20209:5;;;;;8023:20;4336:20209;;;;;;;;-1:-1:-1;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;8023:20;4336:20209;;;;;;18883:1470:2;;4336:20209:5;;3207:622:3;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8023:20;4336:20209;;;;-1:-1:-1;;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;-1:-1:-1;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;4336:20209:5;;3207:622:3;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;-1:-1:-1;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18883:1470:2;;4336:20209:5;;3207:622:3;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;;;3207:622:3;;;;4336:20209:5;3207:622:3;;;;;;;;;;;;;;;;;;;4336:20209:5;3207:622:3;4336:20209:5;3207:622:3;;4336:20209:5;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5073:24;4336:20209;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;17266:205:1;;;4336:20209:5;17266:205:1;4336:20209:5;17266:205:1;;;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;4336:20209:5;9629:76:2;15179:154;;;9629:76;;;;4336:20209:5;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;12478:70:0;;:::i;:::-;4336:20209:5;24423:15;4336:20209;;;;24441:15;-1:-1:-1;24419:82:5;;4336:20209;;6813:405:0;;;-1:-1:-1;;;;;;;;;;;6813:405:0;;;4336:20209:5;-1:-1:-1;;6813:405:0;4336:20209:5;24419:82;4336:20209;;;24458:26;4336:20209;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;-1:-1:-1;;4336:20209:5;24497:4;4336:20209;;;24419:82;;4336:20209;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;7300:148:1;;;4336:20209:5;7300:148:1;4336:20209:5;7300:148:1;;;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;:::i;:::-;;;;5551:91;4336:20209;;;;;;;;;;;;;;;;;;5551:91;;4336:20209;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5434:41;4336:20209;5434:41;;;;;;4336:20209;5434:41;;:::i;:::-;-1:-1:-1;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;4336:20209:5;;;;6720:9:2;4336:20209:5;;:::i;:::-;6708:10:2;6720:9;:::i;4336:20209:5:-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;9831:339:0;;;;4336:20209:5;9831:339:0;4336:20209:5;9831:339:0;;;;;;4336:20209:5;9831:339:0;;4336:20209:5;;;;;;;-1:-1:-1;;4336:20209:5;;;;;16610:16;4336:20209;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;-1:-1:-1;;;;;4336:20209:5;;;;;;17710:14;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;17789:9;4336:20209;17784:98;17800:10;;;;;;4336:20209;;;;;;;;17812:3;17864:6;;;17831:40;4336:20209;17864:6;17840:31;17864:6;;;;:::i;:::-;4336:20209;17840:31;;:::i;:::-;17831:40;;:::i;:::-;17812:3;4336:20209;17789:9;;;;;;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;4336:20209:5;;;;22948:4;4336:20209;;;;-1:-1:-1;;;;;4336:20209:5;;22942:10;;:26;;4336:20209;22938:51;;4336:20209;;;;;22999:786;;4336:20209;24348:887:1;;;;13699:10:5;4336:20209;24348:887:1;4336:20209:5;24348:887:1;;;;;;;;;;;;12442:6:2;24348:887:1;;;;;;;;;;;4336:20209:5;24348:887:1;4336:20209:5;13699:10;-1:-1:-1;;;;;;;;;;;4336:20209:5;24348:887:1;;13699:10:5;12122:18:2;12118:128;;4336:20209:5;5068:216:2;;;4336:20209:5;5068:216:2;;;;12291:80;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12291:80:2;:::i;:::-;13699:10:5;;12410:15:2;13699:10:5;12410:15:2;:::i;:::-;12427:13;;:::i;12118:128::-;5068:216;;;4336:20209:5;5068:216:2;;;;12156:79;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12156:79:2;:::i;:::-;12118:128;;;;22999:786:5;13699:10;23136;;:30;;;22999:786;23136:53;;;22999:786;23132:643;22999:786;23132:643;4336:20209;;;23214:26;4336:20209;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;22999:786;23209:552;4336:20209;;;;;23272:15;:33;23268:475;4336:20209;;;7300:148:1;;23214:26:5;7300:148:1;4336:20209:5;7300:148:1;;23354:21:5;7300:148:1;4336:20209:5;23214:26;7300:148:1;;23354:21:5;:::i;:::-;23423:15;4336:20209;23409:29;;;;4336:20209;;23268:475;;;23209:552;22999:786;;4336:20209;;;;;;;;;;;;;23268:475;-1:-1:-1;;;;4336:20209:5;22948:4;4336:20209;;;;;;-1:-1:-1;;;;;;;;;;;23694:26:5;4336:20209;;23694:26;23268:475;;23136:53;23184:4;;23170:19;;23136:53;;:30;;4336:20209;23136:30;;22938:51;22977:12;;;4336:20209;22977:12;4336:20209;;22977:12;22942:26;4336:20209;;;;;;22942:26;;4336:20209;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;4581:22;4336:20209;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4581:22;4336:20209;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;5068:216:2;;;;4336:20209:5;5068:216:2;;;;4336:20209:5;5068:216:2;4336:20209:5;6039:20:2;;;6035:54;;15179:154;4336:20209:5;15179:154:2;4336:20209:5;15179:154:2;;;;6106:74;4336:20209:5;18883:1470:2;4336:20209:5;18883:1470:2;;5068:216;18883:1470;;;;;;;;;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;;18883:1470:2;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;18883:1470:2;;;;;;;;;;;;;;;;;;;;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;15240:6;4336:20209;;15228:10;15240:6;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;14923:6;4336:20209;;;;14899:10;14923:6;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;21845:344:1;4336:20209:5;;:::i;:::-;;;;;;21722:24:1;4336:20209:5;21845:344:1;;-1:-1:-1;;;;;;;;;;;21845:344:1;;;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;21845:344:1;;;;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;6553:2:1;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;9239:383:0;;;;4336:20209:5;9239:383:0;7972:9;9132:15;4336:20209:5;9239:383:0;;;;;;4336:20209:5;9239:383:0;;4336:20209:5;;;;;;;-1:-1:-1;;4336:20209:5;;;;;4674:27;4336:20209;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;:::i;:::-;;;11300:6:1;;;;;;:::i;:::-;11485:2201;4336:20209:5;11485:2201:1;;;;;;4336:20209:5;11485:2201:1;;;;4336:20209:5;11485:2201:1;;;;;;;;;12442:6:2;11485:2201:1;12427:13:2;11485:2201:1;;12410:15:2;11485:2201:1;;;;;4336:20209:5;11485:2201:1;4336:20209:5;11485:2201:1;;;;;;;;;4336:20209:5;11485:2201:1;;;4336:20209:5;11485:2201:1;8363:339;;;;;11485:2201;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;11485:2201:1;;12122:18:2;12118:128;;4336:20209:5;-1:-1:-1;;;;;4336:20209:5;;12410:15:2;12255:127;;5068:216;;;4336:20209:5;5068:216:2;;;;12291:80;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12291:80:2;:::i;:::-;12255:127;;12410:15;:::i;12118:128::-;5068:216;;;4336:20209:5;5068:216:2;;;;12156:79;5068:216;4336:20209:5;5068:216:2;4336:20209:5;12156:79:2;:::i;:::-;12118:128;;;;11485:2201:1;;4336:20209:5;11485:2201:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4336:20209:5;11485:2201:1;4336:20209:5;11485:2201:1;;4336:20209:5;;;;;;-1:-1:-1;;4336:20209:5;;;;;17320:35;4336:20209;;:::i;:::-;;;17320:35;;:::i;4336:20209::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;12216:12:5;4336:20209;;;;;;;;;-1:-1:-1;;;;;;4336:20209:5;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;-1:-1:-1;;;4336:20209:5;12216:12;4336:20209;;;;;12311:26;4336:20209;;;;;;;-1:-1:-1;;4336:20209:5;8363:339:1;4336:20209:5;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;7028:68:1;;4336:20209:5;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5163:32;4336:20209;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;4977:19;4336:20209;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;:::i;:::-;;;;5996:75;4336:20209;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;8363:339:1;;;;;;;;;;;4336:20209:5;8764:413:1;;;;;4336:20209:5;8764:413:1;;;;;;4336:20209:5;8764:413:1;;;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;8764:413:1;4336:20209:5;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;4336:20209:5;;;;;;5333:30;4336:20209;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;:::o;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;:::o;:::-;;;;;-1:-1:-1;;4336:20209:5;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;:::o;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:::o;:::-;-1:-1:-1;4336:20209:5;;;;;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5434:41;4336:20209;;;;;;5434:41;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;-1:-1:-1;4336:20209:5;:::o;:::-;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;-1:-1:-1;;4336:20209:5;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;:::o;:::-;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;4336:20209:5;;;;;;:::o;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;6258:305:2:-;6394:163;;;4336:20209:5;6394:163:2;;;;;;6258:305;:::o;:::-;6394:163;;;;;;;;;6258:305;:::o;2524:9:5:-;;;;;:::o;:::-;;;;;;;4336:20209;;2524:9;;;;;;;;;;;;:::o;7549:495:1:-;;-1:-1:-1;;;;;4336:20209:5;;5869:42:1;7746:19;7742:49;;7854:184;;;;;4336:20209:5;7854:184:1;;;;;7549:495;:::o;7742:49::-;18883:1470:2;;;;7767:24:1;:::o;7292:355:0:-;-1:-1:-1;;7390:251:0;;;;;7292:355::o;7390:251::-;;;;;;;18373:826:5;8363:339:1;;;;;4336:20209:5;-1:-1:-1;4336:20209:5;18501:9;4336:20209;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;-1:-1:-1;4336:20209:5;;;;18595:16;;;18591:30;;18659:28;;;:::i;:::-;4336:20209;;;;;;;:::i;:::-;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;;;;;;;;;;;;18750:12;4336:20209;;18837:15;;4336:20209;18837:15;:::i;:::-;18709;18833:19;18829:33;;4336:20209;;18943:18;;-1:-1:-1;;;;;4336:20209:5;18943:18;;:::i;:::-;18709:15;18938:23;8363:339:1;;18977:20:5;;19117:17;18977:20;18934:154;;19117:17;4336:20209;19151:17;;;;;;19171;;;:::i;:::-;18373:826;:::o;19151:41::-;;;-1:-1:-1;18373:826:5;:::o;18934:154::-;19053:9;18709:15;;19053:9;:::i;:::-;2387;;;;;;;;;4336:20209;-1:-1:-1;;;;;4336:20209:5;146:4:6;;;;19117:17:5;146:4:6;;18934:154:5;;;146:4:6;4336:20209:5;;;-1:-1:-1;146:4:6;;;;;-1:-1:-1;146:4:6;18829:33:5;18854:8;;;;-1:-1:-1;18854:8:5;:::o;18591:30::-;18613:8;;;-1:-1:-1;18613:8:5;:::o;22839:952::-;22948:4;4336:20209;;22839:952;;-1:-1:-1;;;;;4336:20209:5;;;;22839:952;4336:20209;;22942:10;;;:26;;22839:952;22938:51;;4336:20209;;;;;22999:786;;22839:952;;;;;;:::o;22999:786::-;-1:-1:-1;;;;;4336:20209:5;23136:10;;;;:30;;22999:786;23136:53;;;22999:786;23132:643;;22999:786;;;;23132:643;-1:-1:-1;4336:20209:5;23214:26;4336:20209;;;;-1:-1:-1;4336:20209:5;;;23213:31;23209:552;;23132:643;;;;23209:552;4336:20209;;;;;23272:15;:33;23268:475;4336:20209;;;23354:21;7300:148:1;;;23214:26:5;7300:148:1;-1:-1:-1;7300:148:1;4336:20209:5;23214:26;7300:148:1;;23354:21:5;:::i;:::-;23423:15;4336:20209;23409:29;;;;4336:20209;;23268:475;;;23209:552;;;;;23268:475;-1:-1:-1;;;;;;4336:20209:5;22948:4;4336:20209;;;;;;-1:-1:-1;;;;;;;;;;;23694:26:5;4336:20209;;23694:26;23268:475;;23136:53;23184:4;;23170:19;;;23136:53;;:30;23150:16;;;;23136:30;;22942:26;4336:20209;;;;;;22942:26;;4336:20209;;;;;;:::o;:::-;;;;;;;;;;;;;20045:623;;;20142:76;4336:20209;20163:16;4336:20209;20150:36;;20142:76;:::i;:::-;20249:35;;;;:::i;:::-;20302:13;;4336:20209;;-1:-1:-1;;;;;;;;;;;20614:47:5;4336:20209;;20352:10;;;;20372:19;;;20364:77;20372:19;;;20364:77;:::i;:::-;20592:6;8363:339:1;;;;;;4336:20209:5;;;;-1:-1:-1;4336:20209:5;20485:9;4336:20209;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;20485:49;4336:20209;-1:-1:-1;4336:20209:5;20485:49;:59;4336:20209;;;20485:59;:::i;:::-;4336:20209;;20572:4;20592:6;:::i;:::-;4336:20209;;;;;20614:47;20045:623::o;20348:126::-;20456:18;;20348:126;;4336:20209;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;20858:1454;;8363:339:1;;;;;4336:20209:5;;;;-1:-1:-1;4336:20209:5;20961:14;4336:20209;;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;-1:-1:-1;4336:20209:5;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;;4336:20209:5;;;:::i;:::-;;;;;;;-1:-1:-1;21217:9:5;-1:-1:-1;21228:10:5;;;;;;21212:253;21533:15;;;21525:69;21533:15;;;;21525:69;:::i;:::-;21604:14;21686:10;;;4336:20209;;-1:-1:-1;21811:3:5;21799:10;;;;;;;21834;;;;:::i;:::-;4336:20209;21830:383;;21811:3;;4336:20209;;21788:9;;21830:383;21887:10;;;;;;:::i;:::-;4336:20209;21887:18;:39;;;;;;4336:20209;-1:-1:-1;4336:20209:5;21976:9;4336:20209;;;-1:-1:-1;4336:20209:5;21999:6;;;;:::i;:::-;4336:20209;-1:-1:-1;4336:20209:5;;;;;-1:-1:-1;4336:20209:5;21976:45;4336:20209;;;;;;;22142:6;;;;;:::i;:::-;4336:20209;;-1:-1:-1;;;;;;;;;;;4336:20209:5;;;;;;22114:45;22181:10;22177:21;;21830:383;;;22177:21;22193:5;;;;;22298:6;22193:5;;21783:440;22278:4;22298:6;:::i;21887:39::-;21916:10;;;;:::i;:::-;4336:20209;21887:39;;;;21799:10;;;;;;;22298:6;21799:10;;;;21240:3;21296:6;;;;;;;21317:19;21296:6;21272:31;21296:6;;;;:::i;:::-;4336:20209;21272:31;;:::i;:::-;21259:44;;;;:::i;:::-;4336:20209;21326:10;;;;:::i;:::-;4336:20209;21317:19;;:::i;:::-;21354:10;;;;:29;;;21240:3;21350:105;;4336:20209;;21217:9;;;;;;;;;;21350:105;21403:14;;;;21525:69;21403:14;;;;;21435:5;;;;21354:29;21368:15;;;;;21354:29;;4336:20209;;;;;;;;;;;;;;;;;;14022:660:2;14650:24;14022:660;8363:339:1;;;;;14169:436:2;;;;;;;-1:-1:-1;14169:436:2;;;;;;;;;;;;;;;;-1:-1:-1;14169:436:2;;7300:148:1;14169:436:2;7300:148:1;-1:-1:-1;7300:148:1;;14169:436:2;7300:148:1;;14650:24:2;;:::i;24169:374:5:-;4336:20209;24423:15;4336:20209;;;;24441:15;-1:-1:-1;24419:82:5;;24169:374;8363:339:1;;;;;6813:405:0;;;;;-1:-1:-1;;;;;;;;;;;;6813:405:0;;-1:-1:-1;;6813:405:0;24169:374:5:o;24419:82::-;-1:-1:-1;;;;;4336:20209:5;;-1:-1:-1;4336:20209:5;;;24458:26;4336:20209;;;;;;;-1:-1:-1;;4336:20209:5;8363:339:1;4336:20209:5;;;24419:82;;22599:1172:1;22948:4:5;4336:20209;-1:-1:-1;;;;;4336:20209:5;;;;22599:1172:1;;4336:20209:5;;;22942:10;;;:26;;22599:1172:1;22938:51:5;;4336:20209;;;;;22999:786;;22599:1172:1;22766:946;;;;;;;;;;;;12442:6:2;22766:946:1;;;;;;;22698:1;22766:946;;;;;;;;;;;;;;;;;22698:1;-1:-1:-1;;;;;;;;;;;22766:946:1;;;5068:216:2;;;;22698:1:1;5068:216:2;;;;;;4336:20209:5;5068:216:2;4336:20209:5;12156:79:2;;;;;:::i;:::-;12259:16;;;12255:127;;22599:1172:1;12410:15:2;;;12427:13;12410:15;;:::i;12255:127::-;12291:80;5068:216;;;;12291:80;:::i;:::-;12255:127;;;;;22766:946:1;;22698:1;22766:946;;;;22999:786:5;23136:10;;;:30;;;22999:786;23136:53;;;22999:786;23132:643;22999:786;23132:643;4336:20209;22698:1:1;4336:20209:5;23214:26;4336:20209;;;;22698:1:1;4336:20209:5;;;22999:786;23209:552;4336:20209;;;;;23272:15;:33;23268:475;4336:20209;;;7300:148:1;;23214:26:5;7300:148:1;;22698:1;7300:148;23354:21:5;7300:148:1;4336:20209:5;23214:26;7300:148:1;;23354:21:5;:::i;:::-;23423:15;4336:20209;23409:29;;;;4336:20209;;23268:475;;;23209:552;22999:786;;23268:475;-1:-1:-1;;;;4336:20209:5;22948:4;4336:20209;;;;;;-1:-1:-1;;;;;;;;;;;23694:26:5;4336:20209;;23694:26;23268:475;;23136:53;23184:4;;23170:19;;;23136:53;;:30;;;22942:26;4336:20209;;;;;;22942:26;;25644:1396:1;;;25763:6;;;;;:::i;:::-;25823:1164;;;;;;;;;;;;;;;;;12442:6:2;25823:1164:1;12427:13:2;25823:1164:1;;12410:15:2;25823:1164:1;;;;;;;;;;;;;;;;;;;;;;;8363:339;;;;;25823:1164;;;;-1:-1:-1;;;;;;;;;;;25823:1164:1;;;12122:18:2;12118:128;;-1:-1:-1;;;;;4336:20209:5;;12259:16:2;12255:127;;12410:15;:::i;12614:1260::-;;;12715:20;;12711:33;;-1:-1:-1;;;;;4336:20209:5;;;;;;;;12856:24:2;;;12852:37;;12902:16;12898:484;;12614:1260;13395:14;;;13391:477;;12614:1260;;;:::o;13391:477::-;15179:154;;;12733:1;15179:154;;;;5068:216;;;;12733:1;5068:216;;;;4336:20209:5;5068:216:2;4336:20209:5;12733:1:2;15520:16;15595:2440;;;4336:20209:5;15595:2440:2;5068:216;15595:2440;;;;;;;;;;;;;;;18883:1470;;;15595:2440;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15595:2440:2;15179:154;15595:2440;;;4336:20209:5;15595:2440:2;;;;;;;;;;;;;5068:216;15595:2440;;;;;;;;;;;;;;;;;;5068:216;15595:2440;;;;;;;;12733:1;13613:245;;;-1:-1:-1;;;;;;;;;;;13613:245:2;12733:1;13613:245;12614:1260::o;15595:2440::-;;;;;;;;;5068:216;15595:2440;;;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;13547:4;15595:2440;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;;;;;8363:339:1;15595:2440:2;;;;;;;;;;;;;;12898:484;15179:154;;;12733:1;15179:154;;;;5068:216;;;12733:1;5068:216;;;;4336:20209:5;5068:216:2;4336:20209:5;12989:75:2;15595:2440;;;4336:20209:5;15595:2440:2;5068:216;15595:2440;;;;;;;;;;;;;18883:1470;;;15595:2440;;;;;;;;;;;;;;;;;;;;;;;;;;;12733:1;15595:2440;15179:154;15595:2440;;;4336:20209:5;15595:2440:2;;;;;;;;;;;;;5068:216;15595:2440;;;;;;;;;;;;;;;;;;5068:216;15595:2440;;;;;;;;12733:1;13125:247;;;-1:-1:-1;;;;;;;;;;;13125:247:2;12733:1;13125:247;12898:484;;;;15595:2440;;;;;;;;;5068:216;15595:2440;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;-1:-1:-1;15595:2440:2;;;;12733:1;15595:2440;15179:154;15595:2440;;12711:33;12737:7;;;:::o;19616:204:5:-;;4336:20209;;19748:64;;;;4336:20209;2785:57;4336:20209;;8363:339:1;;;;;4336:20209:5;;2785:57;;4336:20209;2785:57;;;4336:20209;2785:57;19748:64;;;;;;:::i;:::-;4336:20209;19738:75;;19616:204;:::o;15379:2662:2:-;;;4336:20209:5;15179:154:2;4336:20209:5;;15595:2440:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15595:2440:2;;;;4336:20209:5;15595:2440:2;;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;;;;;;;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15379:2662::o;15595:2440::-;;;;;;;;;;;;;;;15379:2662::o;15595:2440::-;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;15595:2440:2;12230:4;15595:2440;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;;12230:4;15595:2440;;;;;;;;;;;;;;;;;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;;15595:2440:2;15379:2662::o;15595:2440::-;-1:-1:-1;15595:2440:2;;;;;;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;15595:2440:2;15379:2662::o;:::-;;;4336:20209:5;15179:154:2;4336:20209:5;;15595:2440:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15595:2440:2;;;;4336:20209:5;15595:2440:2;;;;;;;;;-1:-1:-1;;;15595:2440:2;;;;;;;;;;;;;;;;;;;4336:20209:5;15595:2440:2;;;;;;;;;-1:-1:-1;15595:2440:2;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;15595:2440:2;-1:-1:-1;;;;15595:2440:2;15379:2662::o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceLimitEnd()","signatureHash4":"0xcd6106f8","signatureHash32":"0xcd6106f8083a8766160043f1a7de38f80a9a46c430f4d83458fa49bf6af421ed"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"burn(uint256)","signatureHash4":"0x42966c68","signatureHash32":"0x42966c689b5afe9b9b3f8a7103b2a19980d59629bfd6a20a60972312ed41d836"},{"signature":"cancelOwnershipHandover()","signatureHash4":"0x54d1f13d","signatureHash32":"0x54d1f13d76f000aa202485e9c4b750a3fb26985ca34157c621201e1375bcbfac"},{"signature":"checkpointAt(address,uint256)","signatureHash4":"0x84a0e082","signatureHash32":"0x84a0e0822409b97df8bbb5f443f9a53fba187d91ed1e93f860deac39ff1f9593"},{"signature":"checkpointCount(address)","signatureHash4":"0x76a82342","signatureHash32":"0x76a82342260a7f1e16a39c55dfb2de538a9645f30b4e466e0519af7120f05d54"},{"signature":"clock()","signatureHash4":"0x91ddadf4","signatureHash32":"0x91ddadf40f7f6ebb77645f9e322f9b8d0ad46a2c9cb2f52a073cd7c5e16d557a"},{"signature":"CLOCK_MODE()","signatureHash4":"0x4bf5d7e9","signatureHash32":"0x4bf5d7e9b6c61a22cbf64ce287b6d2ab7d20c1daf2af0387ee347ff904cd25f5"},{"signature":"completeOwnershipHandover(address)","signatureHash4":"0xf04e283e","signatureHash32":"0xf04e283ea4b43821701876734697fc3e4a42281d51fee656e5c166b741e6afde"},{"signature":"computeAvailableVestedAmount(address)","signatureHash4":"0x4c869795","signatureHash32":"0x4c8697953d863389a62ac5be0b321affcf269bd7dbdd2a74a8427ac9d818a8ed"},{"signature":"computeAvailableVestedAmount(address,uint256)","signatureHash4":"0x23386469","signatureHash32":"0x2338646924efb53215cbc8f0570d82d165e57c3203c45005b6bdb8a05be7be53"},{"signature":"controller()","signatureHash4":"0xf77c4791","signatureHash32":"0xf77c479193cde57766d8942951485a8f17f392317496eb71bad328979039b747"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"delegate(address)","signatureHash4":"0x5c19a95c","signatureHash32":"0x5c19a95c96fe5699f69181241d04ecef12a0c89506c08c7360f0f7e9a556859f"},{"signature":"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)","signatureHash4":"0xc3cda520","signatureHash32":"0xc3cda520413c90ac2c469da30542aa0b90cd877a87f60aecc55e99ec7019c59e"},{"signature":"delegates(address)","signatureHash4":"0x587cde1e","signatureHash32":"0x587cde1e7a8c573b1844af1585c2f1cfd2d254aa7bdef08253e217600cd8476c"},{"signature":"disableBalanceLimit()","signatureHash4":"0x91c46371","signatureHash32":"0x91c4637158cd0a5d63e6836da1b81433a937e80c0d6abb7b88a2c6f4c41ac9a4"},{"signature":"DOMAIN_SEPARATOR()","signatureHash4":"0x3644e515","signatureHash32":"0x3644e5157256d68e3eeedd2ead302507a9c4ffaff665547d2c3623a1e9e7edf4"},{"signature":"getPastVotes(address,uint256)","signatureHash4":"0x3a46b1a8","signatureHash32":"0x3a46b1a8034ed3adfd5d8c1bf75e426a415502bced856c6b8d65c6d81fd746ce"},{"signature":"getPastVotesTotalSupply(uint256)","signatureHash4":"0xc7a2f1de","signatureHash32":"0xc7a2f1de27c374d3e39c04e42e79186000394959e7f8ecaab16cc0deb1eebfc2"},{"signature":"getScheduleIdsOf(address)","signatureHash4":"0xd2482469","signatureHash32":"0xd248246928e2eadeac50035b1b923b5b87cd1fcb12f59d58c20f7bbc3a7507ab"},{"signature":"getVotes(address)","signatureHash4":"0x9ab24eb0","signatureHash32":"0x9ab24eb0086abe93529cb36564cc78c9de7e8a990a4616ff863202cfd413aa9e"},{"signature":"getVotesTotalSupply()","signatureHash4":"0xcd63c4d2","signatureHash32":"0xcd63c4d227697190e412d1728ff34c242a28992014992e85ec1bee086abd12e2"},{"signature":"initialize(string,string,uint256,address,address,(uint64,uint64)[],address[],uint256[],uint256[],string,uint256,uint48,address,address[])","signatureHash4":"0x8071cdfa","signatureHash32":"0x8071cdfa88aa24055684b66f03e260704032ca4f9abbf57983ab5e4e2eba0936"},{"signature":"isBalanceLimitActive()","signatureHash4":"0x17fc70ee","signatureHash32":"0x17fc70ee50cf42164ee3ec65ca1c112249511000cfb3e10de1bfe346ffe5c636"},{"signature":"isExcludedFromBalanceLimit(address)","signatureHash4":"0x12d10c4a","signatureHash32":"0x12d10c4a768eab31cd96c099ea87beb3a23edd4a0234081b492dedeb39fac01a"},{"signature":"isPoolLocked()","signatureHash4":"0x800f57cb","signatureHash32":"0x800f57cb443378cb35761f6ca7483ba7766bf52ff6d08fd78f947a31630db305"},{"signature":"lockPool(address)","signatureHash4":"0x207d0636","signatureHash32":"0x207d0636ebe9379a51116efc6389e6c615b4b12756c93fc3bdb7e6f70f56be38"},{"signature":"maxBalanceLimit()","signatureHash4":"0x04dfe79d","signatureHash32":"0x04dfe79daa9990af29fc452bd235669336c7cb380eb5ac8b8453a2408e196bba"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"nonces(address)","signatureHash4":"0x7ecebe00","signatureHash32":"0x7ecebe00bc8d5df94a191da8e29b79e67a22b668e14b756a81ef2f5fa215cb0c"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"ownershipHandoverExpiresAt(address)","signatureHash4":"0xfee81cf4","signatureHash32":"0xfee81cf4fcd7f51611a3bf33478e3ef123da30b6dfa31a0b2a6d1192ef3c7e02"},{"signature":"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)","signatureHash4":"0xd505accf","signatureHash32":"0xd505accfee7b46ac3ce97322c21f328b64073d188137e16f7ef87f8de076b51c"},{"signature":"pool()","signatureHash4":"0x16f0115b","signatureHash32":"0x16f0115b5901d3f6295e520505af05475e18f6f1e134f347475c881a6302260d"},{"signature":"releaseFor(address,uint256)","signatureHash4":"0xbeb96be5","signatureHash32":"0xbeb96be5589995a08e2db4f5f12ba6c326f726fc9ff62a0efe6b347764db2eb3"},{"signature":"releaseFor(address,uint256,uint256)","signatureHash4":"0xd699d7d2","signatureHash32":"0xd699d7d280ef9276c9299d945d27a849f8c84a3f400b02de403159ed00afc483"},{"signature":"release(uint256)","signatureHash4":"0x37bdc99b","signatureHash32":"0x37bdc99b314603e743f78bee63876bfb568cfc91a882f47d10f9b12eb44b6d3f"},{"signature":"release(uint256,uint256)","signatureHash4":"0x366a4120","signatureHash32":"0x366a4120324b690305df4b9eea8fb6412cc8fb8ceefe1b1f6b57c5b226981ceb"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"requestOwnershipHandover()","signatureHash4":"0x25692962","signatureHash32":"0x25692962a9adba4272ff0251e0e6793c55bbf553e4476049416aa620e8960301"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"tokenURI()","signatureHash4":"0x3c130d90","signatureHash32":"0x3c130d90a3a3102bb1d43caeb4a43be8c3d9837b9c8f5a1bae2d0b50edd19a88"},{"signature":"totalAllocatedOf(address)","signatureHash4":"0xf5009604","signatureHash32":"0xf5009604efaa66cd7ecd85887247631e8342d253365cfbffc2d94db3043c8115"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"unlockPool()","signatureHash4":"0x89026538","signatureHash32":"0x89026538b78cd1cfbabbb7f46eddea39a843cee10c395f8a6dc1eb3adc1a2ada"},{"signature":"updateTokenURI(string)","signatureHash4":"0x98cd6153","signatureHash32":"0x98cd61538a481ea637e43ec2085986faccb1ae2b7bfea66cae7f06485442e002"},{"signature":"vestedTotalAmount()","signatureHash4":"0xf68d90d8","signatureHash32":"0xf68d90d880758aa0250e2f06c21ae8cf416698c604c1368b1aceb2911fb1351e"},{"signature":"vestingOf(address,uint256)","signatureHash4":"0x6f503e67","signatureHash32":"0x6f503e678715ce57f4395b8f059a8b26978895def2c041ebf286df412e8a66a5"},{"signature":"vestingScheduleCount()","signatureHash4":"0x53c7efa9","signatureHash32":"0x53c7efa9dfee94da72069ecf28cb9bc198878e7e5783f810077a6128ad374dd4"},{"signature":"vestingSchedules(uint256)","signatureHash4":"0x6d3cbe21","signatureHash32":"0x6d3cbe219721e3be3f4fb2a985f4f8a45723284d1b264b85885bf6c887fd1885"},{"signature":"vestingStart()","signatureHash4":"0x254800d4","signatureHash32":"0x254800d4160c7e4543e7e357a70cb354a84b4983fee3f84f99b3ef5f35e77f86"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"BalanceLimitDisabled(bool)","signatureHash4":"0xde7efbfa","signatureHash32":"0xde7efbfa85e22db1ead49b6dfd1e807893247c3e22f7ded13eb9f9856a807661"},{"signature":"DelegateChanged(address,address,address)","signatureHash4":"0x3134e8a2","signatureHash32":"0x3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f"},{"signature":"DelegateVotesChanged(address,uint256,uint256)","signatureHash4":"0xdec2bacd","signatureHash32":"0xdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a724"},{"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":"TokensReleased(address,uint256,uint256)","signatureHash4":"0xc5c52c2a","signatureHash32":"0xc5c52c2a9175470464d5ea4429889e7df2ea88630a3d32f4d0d3d2d448656210"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"},{"signature":"UpdateTokenURI(string)","signatureHash4":"0x97b44a94","signatureHash32":"0x97b44a9429ef39a6d23e2de72846304d5b7873011084c4f1368f7a46545d5173"},{"signature":"VestingAllocated(address,uint256,uint256)","signatureHash4":"0x6b467f0a","signatureHash32":"0x6b467f0a76daac5283d2251b6e7660fed01ea99dbd70aa7092f3318731690c9d"},{"signature":"VestingScheduleCreated(uint256,uint64,uint64)","signatureHash4":"0xde48917a","signatureHash32":"0xde48917a7c688e2f10cf41d45c1a7529ec84f5f9b9a08866ecf9453c417ad2c5"}],"error":[{"signature":"AllowanceOverflow()","signatureHash4":"0xf9067066","signatureHash32":"0xf90670665e03a4773b0ff0038950e59dcf6eb0e11a551c751bfc6d601d4fba1f"},{"signature":"AllowanceUnderflow()","signatureHash4":"0x8301ab38","signatureHash32":"0x8301ab3813d043283976247523a0a38774b9155d7216ecc20ceae2039c28e28f"},{"signature":"AlreadyInitialized()","signatureHash4":"0x0dc149f0","signatureHash32":"0x0dc149f07762891dbcea3fe72770f3d63a1863fc54b2f084e8c59ec476996927"},{"signature":"ArrayLengthsMismatch()","signatureHash4":"0x3b800a46","signatureHash32":"0x3b800a46f30adefac76e87040bda517104790d5336c971a6b88a442fc4c4e039"},{"signature":"BalanceLimitExceeded(uint256,uint256)","signatureHash4":"0xe38912a8","signatureHash32":"0xe38912a8069cb641aa91b01ae993ca5e0c1a959a2365a7bdb0424cbf940176e9"},{"signature":"BalanceLimitNotActive()","signatureHash4":"0x1ca934f2","signatureHash32":"0x1ca934f22195d2338b74183b551cd1d02291a7e15b25dd49d35ff19c9935b016"},{"signature":"ERC5805CheckpointIndexOutOfBounds()","signatureHash4":"0x86df9d10","signatureHash32":"0x86df9d1096a77e2f351cc6918bf186b9828c1bc551b615f4f27033286427589a"},{"signature":"ERC5805CheckpointValueOverflow()","signatureHash4":"0x9dbbeb75","signatureHash32":"0x9dbbeb7597ed4c8a6e34e32bf4350afae9d28fe79da2982d884a4d7e5b9ac4ca"},{"signature":"ERC5805CheckpointValueUnderflow()","signatureHash4":"0x5915f686","signatureHash32":"0x5915f686ed04a2e3119fe1f2f38129cf8e7c3d901d404576a5a4379b864738ea"},{"signature":"ERC5805DelegateInvalidSignature()","signatureHash4":"0x1838d95c","signatureHash32":"0x1838d95cd46fcfadd423d3217eb46c5f4334ecad8f15f73fe858c495e19003ef"},{"signature":"ERC5805DelegateSignatureExpired()","signatureHash4":"0x3480e9e1","signatureHash32":"0x3480e9e1cd14a3a585a49e8823bea2b5d7bf4dbd27689018d308ec527ad07a46"},{"signature":"ERC5805FutureLookup()","signatureHash4":"0xf9874464","signatureHash32":"0xf98744647cf2f7fa23bc79d54329d9f959a2ad1a9f71fb57a00e38ba5d27ac0f"},{"signature":"InsufficientAllowance()","signatureHash4":"0x13be252b","signatureHash32":"0x13be252bc8f22c3de689f75d88d90b4c4aeb9cd39d50c39ae82df3b19f85cf73"},{"signature":"InsufficientBalance()","signatureHash4":"0xf4d678b8","signatureHash32":"0xf4d678b8ce6b5157126b1484a53523762a93571537a7d5ae97d8014a44715c94"},{"signature":"InsufficientReleasableAmount(uint256,uint256)","signatureHash4":"0x7ab3846b","signatureHash32":"0x7ab3846b5373a620dbabbc8c718feb3b009da23ac61090f1062dd421b5a9ab34"},{"signature":"InvalidAllocation(uint256)","signatureHash4":"0x6f677338","signatureHash32":"0x6f677338b3cba228e778f8c93209da0d6b4920c12d862b0c0031e129869d178a"},{"signature":"InvalidBalanceLimitTimestamp(uint256,uint256)","signatureHash4":"0x774a2d38","signatureHash32":"0x774a2d3834d68c969da1d2292d0ca00ecd28d14a51cbdf2bdb83a7edd383f8ec"},{"signature":"InvalidBalanceLimit(uint256)","signatureHash4":"0x2a9f5c1f","signatureHash32":"0x2a9f5c1fc430cfab13fb3125b6c14b4bea0145910dd7fd60804a255fe2c3e0da"},{"signature":"InvalidInitialization()","signatureHash4":"0xf92ee8a9","signatureHash32":"0xf92ee8a957075833165f68c320933b1a1294aafc84ee6e0dd3fb178008f9aaf5"},{"signature":"InvalidPermit()","signatureHash4":"0xddafbaef","signatureHash32":"0xddafbaefe5cdbfc41219261b5d7468d1f16bc986eedbdef2ea223830eb9c5e3e"},{"signature":"InvalidSchedule(uint256)","signatureHash4":"0x52fbb5df","signatureHash32":"0x52fbb5df789b7e2d000baf0a70a522e9741e0a6b6c2e33eb92d2e28ec9979cfb"},{"signature":"MaxPreMintPerAddressExceeded(uint256,uint256)","signatureHash4":"0x0887f672","signatureHash32":"0x0887f672292100e749d0cb5fa905e87254740ee0c3a370277356374199369fa0"},{"signature":"MaxTotalPreMintExceeded(uint256,uint256)","signatureHash4":"0x23f3f88b","signatureHash32":"0x23f3f88b3989ddc75617711f4cd9f453d84e3b324ae99e6df4dc0cbe565e3bd3"},{"signature":"MaxTotalVestedExceeded(uint256,uint256)","signatureHash4":"0x05767d17","signatureHash32":"0x05767d17a783e9a85f2d1d8c6a87ecc6e9f32333a2aa5ef119b67510abb20560"},{"signature":"NewOwnerIsZeroAddress()","signatureHash4":"0x7448fbae","signatureHash32":"0x7448fbae245b5163a637f61fac94c5376c3e155928452ce47ee52d8c1b99587a"},{"signature":"NoHandoverRequest()","signatureHash4":"0x6f5e8818","signatureHash32":"0x6f5e8818469c73d5be4a0d17c371cde64695907022629c1d064c895f98d466a6"},{"signature":"NoReleasableAmount()","signatureHash4":"0x47b048bc","signatureHash32":"0x47b048bce65e55a5c3e8294bf93b4ca568d68108883ce2a70028eff8ce484394"},{"signature":"NotInitializing()","signatureHash4":"0xd7e6bcf8","signatureHash32":"0xd7e6bcf8597daa127dc9f0048d2f08d5ef140a2cb659feabd700beff1f7a8302"},{"signature":"Permit2AllowanceIsFixedAtInfinity()","signatureHash4":"0x3f68539a","signatureHash32":"0x3f68539a770258d2bb543cd58b5796e9a7d3756f652a2877fca18c376b7d6d2d"},{"signature":"PermitExpired()","signatureHash4":"0x1a15a3cc","signatureHash32":"0x1a15a3cc224edbade4d933d5c6e98dd80b0bac0717489018b924d44d9f0272ea"},{"signature":"PoolAlreadyLocked()","signatureHash4":"0x5b3d9c43","signatureHash32":"0x5b3d9c430ce131029af44c0ba884249406f960895a3faf594688379428ef116d"},{"signature":"PoolAlreadyUnlocked()","signatureHash4":"0x4bc0a9fb","signatureHash32":"0x4bc0a9fbf206cc3699125df9cd74b5a665192d3544c7a30588e5d6a0b35f8365"},{"signature":"PoolLocked()","signatureHash4":"0x2e136745","signatureHash32":"0x2e136745550967f28b779ce8c395ca060a2f844edfb5b06631fe677f66f9e305"},{"signature":"TotalSupplyOverflow()","signatureHash4":"0xe5cfe957","signatureHash32":"0xe5cfe9574234d28adee0e141da16b8cf97573d6cdb05963cf8520ef32a8feff8"},{"signature":"Unauthorized()","signatureHash4":"0x82b42900","signatureHash32":"0x82b4290015f7ec7256ca2a6247d3c2a89c4865c0e791456df195f40ad0a81367"},{"signature":"UnknownScheduleId(uint256)","signatureHash4":"0x4ed2e7cf","signatureHash32":"0x4ed2e7cfcdf341ca3ede3f0f7c2740d8a9dcb3167c84b31ff6b5cfb918edc123"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"4663","address":"0x3Be8B97Fd0e713B5aBE0649Fa830223B6B4BC599"}