{"matchId":"58832845","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-08T22:30:20Z","creationBytecode":{"onchainBytecode":"0x6102206040526105dc610120818152610140829052610160829052610180919091526103e86101a08190526101c0526101f46101e0819052610200526200004b90601090600862000144565b506123286011553480156200005e575f80fd5b50604051620029eb380380620029eb833981016040819052620000819162000222565b6040518060400160405280601c81526020017fe5b1b1e6b5b7e7bb8fc2b7e585abe88d92e5bc82e585bdc2b7e58f81000000008152506040518060400160405280600881526020016742414855414e473360c01b815250815f9081620000e89190620003c3565b506001620000f78282620003c3565b5050506001600160a01b0380861660805284811660a052831660c0524260e0819052620001269083906200048f565b610100526006620001388282620003c3565b505050505050620004b5565b600183019183908215620001ce579160200282015f5b838211156200019c57835183826101000a81548161ffff021916908361ffff16021790555092602001926002016020816001010492830192600103026200015a565b8015620001cc5782816101000a81549061ffff02191690556002016020816001010492830192600103026200019c565b505b50620001dc929150620001e0565b5090565b5b80821115620001dc575f8155600101620001e1565b6001600160a01b03811681146200020b575f80fd5b50565b634e487b7160e01b5f52604160045260245ffd5b5f805f805f60a0868803121562000237575f80fd5b85516200024481620001f6565b809550506020808701516200025981620001f6565b60408801519095506200026c81620001f6565b6060880151608089015191955093506001600160401b038082111562000290575f80fd5b818901915089601f830112620002a4575f80fd5b815181811115620002b957620002b96200020e565b604051601f8201601f19908116603f01168101908382118183101715620002e457620002e46200020e565b816040528281528c86848701011115620002fc575f80fd5b5f93505b828410156200031f578484018601518185018701529285019262000300565b5f8684830101528096505050505050509295509295909350565b600181811c908216806200034e57607f821691505b6020821081036200036d57634e487b7160e01b5f52602260045260245ffd5b50919050565b601f821115620003be57805f5260205f20601f840160051c810160208510156200039a5750805b601f840160051c820191505b81811015620003bb575f8155600101620003a6565b50505b505050565b81516001600160401b03811115620003df57620003df6200020e565b620003f781620003f0845462000339565b8462000373565b602080601f8311600181146200042d575f8415620004155750858301515b5f19600386901b1c1916600185901b17855562000487565b5f85815260208120601f198616915b828110156200045d578886015182559484019460019091019084016200043c565b50858210156200047b57878501515f19600388901b60f8161c191681555b505060018460011b0185555b505050505050565b80820180821115620004af57634e487b7160e01b5f52601160045260245ffd5b92915050565b60805160a05160c05160e051610100516124c06200052b5f395f81816108a201528181610b5a01528181610e55015261154201525f6103da01525f8181610553015261121401525f81816105ea0152610ac901525f818161085001528181610bcb01528181610ec601526114d401526124c05ff3fe6080604052600436106102bf575f3560e01c8063958c88481161016f578063c87b56dd116100d8578063dbc8b74711610092578063e985e9c51161006d578063e985e9c514610872578063ea2b4ab214610891578063ec6cf70c146108c4578063fb3fecd3146108e3575f80fd5b8063dbc8b74714610817578063ddfbae0d1461082b578063e84f43b71461083f575f80fd5b8063c87b56dd146107a7578063cb2c9722146107c6578063cd90e5af146107da578063d10a1a2b146107ee578063d2aba63314610370578063db9915b314610803575f80fd5b8063a2309ff811610129578063a2309ff81461070d578063aa4ac63f14610721578063ac6a96b114610736578063b88d4fde1461074a578063b98510f914610769578063c343442914610788575f80fd5b8063958c88481461065e57806395d89b411461068c5780639dab2054146106a0578063a0b93856146106bf578063a1542bd2146106d4578063a22cb465146106ee575f80fd5b80633e6c7e751161022b5780636352211e116101e55780636ee5c9fb116101c05780636ee5c9fb1461058857806370a08231146105ba57806382a8de91146105d95780638f79306e1461060c575f80fd5b80636352211e1461052357806363bd1d4a1461054257806365cde73314610575575f80fd5b80633e6c7e75146104795780633e8f87231461049857806342842e0e146104c65780634dbd691f146104e5578063567142be146104fa5780635b70ea9f1461050f575f80fd5b806323b872dd1161027c57806323b872dd146103aa578063255e4685146103c957806327595a801461040a5780632806b8fb146104245780632fe6613414610439578063358b81661461044e575f80fd5b806301ffc9a7146102c357806306fdde03146102f7578063081812fc14610318578063095ea7b31461034f5780630f39f9b9146103705780631249c58b14610396575b5f80fd5b3480156102ce575f80fd5b506102e26102dd366004611fa8565b6108f8565b60405190151581526020015b60405180910390f35b348015610302575f80fd5b5061030b610949565b6040516102ee9190612017565b348015610323575f80fd5b50610337610332366004612029565b6109d8565b6040516001600160a01b0390911681526020016102ee565b34801561035a575f80fd5b5061036e61036936600461205b565b6109ff565b005b34801561037b575f80fd5b50610384600881565b60405160ff90911681526020016102ee565b3480156103a1575f80fd5b5061036e610a0e565b3480156103b5575f80fd5b5061036e6103c4366004612083565b610a18565b3480156103d4575f80fd5b506103fc7f000000000000000000000000000000000000000000000000000000000000000081565b6040519081526020016102ee565b348015610415575f80fd5b506103fc6601c6bf5263400081565b34801561042f575f80fd5b506103fc60085481565b348015610444575f80fd5b506103fc60095481565b348015610459575f80fd5b506103fc6104683660046120bc565b600e6020525f908152604090205481565b348015610484575f80fd5b506102e26104933660046120bc565b610aa6565b3480156104a3575f80fd5b506103846104b23660046120bc565b600d6020525f908152604090205460ff1681565b3480156104d1575f80fd5b5061036e6104e0366004612083565b610b39565b3480156104f0575f80fd5b506103fc61177081565b348015610505575f80fd5b506103fc600b5481565b34801561051a575f80fd5b5061036e610b58565b34801561052e575f80fd5b5061033761053d366004612029565b610e49565b34801561054d575f80fd5b506103377f000000000000000000000000000000000000000000000000000000000000000081565b61036e610583366004612029565b610e53565b348015610593575f80fd5b506105a76105a2366004612029565b611361565b60405161ffff90911681526020016102ee565b3480156105c5575f80fd5b506103fc6105d43660046120bc565b61138e565b3480156105e4575f80fd5b506103377f000000000000000000000000000000000000000000000000000000000000000081565b348015610617575f80fd5b5061062b61062636600461205b565b6113d3565b604080519687526020870195909552938501929092521515606084015215156080830152151560a082015260c0016102ee565b348015610669575f80fd5b506103846106783660046120bc565b600c6020525f908152604090205460ff1681565b348015610697575f80fd5b5061030b61157a565b3480156106ab575f80fd5b506103fc6106ba366004612029565b611589565b3480156106ca575f80fd5b506103fc600a5481565b3480156106df575f80fd5b506103fc6603328b944c400081565b3480156106f9575f80fd5b5061036e6107083660046120d5565b6115af565b348015610718575f80fd5b506103fc6115ba565b34801561072c575f80fd5b506103fc6105dc81565b348015610741575f80fd5b506103fc600581565b348015610755575f80fd5b5061036e610764366004612122565b6115d0565b348015610774575f80fd5b506103fc610783366004612029565b6115e8565b348015610793575f80fd5b506103846107a2366004612029565b611626565b3480156107b2575f80fd5b5061030b6107c1366004612029565b61164e565b3480156107d1575f80fd5b506103fc61168d565b3480156107e5575f80fd5b506103fc600281565b3480156107f9575f80fd5b506103fc60075481565b34801561080e575f80fd5b506103fc601481565b348015610822575f80fd5b506103fc600a81565b348015610836575f80fd5b50610384600981565b34801561084a575f80fd5b506103377f000000000000000000000000000000000000000000000000000000000000000081565b34801561087d575f80fd5b506102e261088c3660046121f7565b611698565b34801561089c575f80fd5b506103fc7f000000000000000000000000000000000000000000000000000000000000000081565b3480156108cf575f80fd5b506103fc6108de3660046120bc565b6116c5565b3480156108ee575f80fd5b506103fc610bb881565b5f6001600160e01b031982166380ac58cd60e01b148061092857506001600160e01b03198216635b5e139f60e01b145b8061094357506301ffc9a760e01b6001600160e01b03198316145b92915050565b60605f805461095790612228565b80601f016020809104026020016040519081016040528092919081815260200182805461098390612228565b80156109ce5780601f106109a5576101008083540402835291602001916109ce565b820191905f5260205f20905b8154815290600101906020018083116109b157829003601f168201915b5050505050905090565b5f6109e2826116e2565b505f828152600460205260409020546001600160a01b0316610943565b610a0a82823361171a565b5050565b610a16610b58565b565b6001600160a01b038216610a4657604051633250574960e11b81525f60048201526024015b60405180910390fd5b5f610a52838333611727565b9050836001600160a01b0316816001600160a01b031614610aa0576040516364283d7b60e01b81526001600160a01b0380861660048301526024820184905282166044820152606401610a3d565b50505050565b6040516370a0823160e01b81526001600160a01b0382811660048301525f9182917f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa158015610b0e573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610b32919061225a565b1192915050565b610b5383838360405180602001604052805f8152506115d0565b505050565b7f00000000000000000000000000000000000000000000000000000000000000004210610bb45760405162461bcd60e51b815260206004820152600a6024820152691b5a5b9d08195b99195960b21b6044820152606401610a3d565b6040516370a0823160e01b81523360048201525f907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906370a0823190602401602060405180830381865afa158015610c18573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610c3c919061225a565b11610c7d5760405162461bcd60e51b81526020600482015260116024820152701b995959080b985a481059d95b9d081251607a1b6044820152606401610a3d565b5f610c87336116c5565b335f908152600c60205260408120549192509060ff168211610ca9575f610cc5565b335f908152600c6020526040902054610cc59060ff1683612285565b90505f8111610d025760405162461bcd60e51b8152602060048201526009602482015268199c9959481d5cd95960ba1b6044820152606401610a3d565b5f600754611770610d139190612285565b90505f8111610d545760405162461bcd60e51b815260206004820152600d60248201526c199c9959481cdbdb19081bdd5d609a1b6044820152606401610a3d565b80821115610d60578091505b335f908152600c602052604081208054849290610d8190849060ff16612298565b92506101000a81548160ff021916908360ff1602179055508160075f828254610daa91906122b1565b9091555050335f908152600e602052604081208054849290610dcd9084906122b1565b9250508190555081600b5f828254610de591906122b1565b909155505f90505b82811015610e0657610dfe33611819565b600101610ded565b506040805183815260058514602082015233917f73bb33365059ea6ca29660beef1bc6ff9f16241f6e85a5d3170dcc45b5644f65910160405180910390a2505050565b5f610943826116e2565b7f00000000000000000000000000000000000000000000000000000000000000004210610eaf5760405162461bcd60e51b815260206004820152600a6024820152691b5a5b9d08195b99195960b21b6044820152606401610a3d565b6040516370a0823160e01b81523360048201525f907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906370a0823190602401602060405180830381865afa158015610f13573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610f37919061225a565b11610f785760405162461bcd60e51b81526020600482015260116024820152701b995959080b985a481059d95b9d081251607a1b6044820152606401610a3d565b5f8111610faf5760405162461bcd60e51b8152602060048201526005602482015264071747920360dc1b6044820152606401610a3d565b335f908152600d6020526040902054601490610fcf90839060ff166122b1565b111561100b5760405162461bcd60e51b815260206004820152600b60248201526a1b585e080c8c081c185a5960aa1b6044820152606401610a3d565b610bb88160085461101c91906122b1565b111561105a5760405162461bcd60e51b815260206004820152600d60248201526c1c185a59081cdbdb19081bdd5d609a1b6044820152606401610a3d565b5f611064826115e8565b9050803410156110a25760405162461bcd60e51b81526020600482015260096024820152681d5b99195c9c185a5960ba1b6044820152606401610a3d565b335f908152600d60205260408120805460ff16918491906110c38385612298565b92506101000a81548160ff021916908360ff1602179055508260085f8282546110ec91906122b1565b9250508190555081600a5f82825461110491906122b1565b9091555061111590508360026122c4565b335f908152600e6020526040812080549091906111339084906122b1565b9091555061114490508360026122c4565b600b5f82825461115491906122b1565b909155505f90505b838110156111755761116d33611819565b60010161115c565b50600a811080156111905750600a61118d84836122b1565b10155b156111d6576111a03360086119bf565b6111ab3360096119bf565b60405133907fcace12c4f853c8b402ff58c2fd1a4a066f2e98b46d8fd47bf4a6320102aed329905f90a25b604080518481526020810184905233917f12d09a8dfc6b5d28033faed5ee2c0555b48cad9ce6b134630c05b50ffe7429c0910160405180910390a25f7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316836040515f6040518083038185875af1925050503d805f811461127a576040519150601f19603f3d011682016040523d82523d5f602084013e61127f565b606091505b50509050806112c05760405162461bcd60e51b815260206004820152600d60248201526c1c185e5bdd5d0819985a5b1959609a1b6044820152606401610a3d565b5f6112cb8434612285565b9050801561135a576040515f90339083908381818185875af1925050503d805f8114611312576040519150601f19603f3d011682016040523d82523d5f602084013e611317565b606091505b50509050806113585760405162461bcd60e51b815260206004820152600d60248201526c1c99599d5b990819985a5b1959609a1b6044820152606401610a3d565b505b5050505050565b60108160088110611370575f80fd5b60109182820401919006600202915054906101000a900461ffff1681565b5f6001600160a01b0382166113b8576040516322718ad960e21b81525f6004820152602401610a3d565b506001600160a01b03165f9081526003602052604090205490565b5f805f805f805f6113e3896116c5565b6001600160a01b038a165f908152600c60205260408120549192509060ff16821161140e575f611433565b6001600160a01b038a165f908152600c60205260409020546114339060ff1683612285565b90505f6007546117706114469190612285565b90508082106114555780611457565b815b6001600160a01b038c165f908152600d6020526040812054919a50906114819060ff166014612285565b90505f600854610bb86114949190612285565b90508082106114a357806114a5565b815b99506114b08c6115e8565b6040516370a0823160e01b81526001600160a01b038f81166004830152919a505f917f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa158015611519573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061153d919061225a565b1197507f00000000000000000000000000000000000000000000000000000000000000004210965060058514955050505050509295509295509295565b60606001805461095790612228565b5f6105dc8211156115a1576603328b944c4000610943565b6601c6bf5263400092915050565b610a0a338383611a16565b5f6008546007546115cb91906122b1565b905090565b6115db848484610a18565b610aa03385858585611add565b5f60015b82811161162057611604816008546106ba91906122b1565b61160e90836122b1565b9150611619816122db565b90506115ec565b50919050565b5f611630826116e2565b505f828152600f60205260409020546109439060019060ff166122f3565b6060600661166661165e84611626565b60ff16611bfc565b604051602001611677929190612327565b6040516020818303038152906040529050919050565b5f6115cb60016115e8565b6001600160a01b039182165f90815260056020908152604080832093909416825291909152205460ff1690565b5f6116cf82610aa6565b6116da576002610943565b600592915050565b5f818152600260205260408120546001600160a01b03168061094357604051637e27328960e01b815260048101849052602401610a3d565b610b538383836001611c8c565b5f828152600260205260408120546001600160a01b039081169083161561175357611753818486611d90565b6001600160a01b0381161561178d5761176e5f855f80611c8c565b6001600160a01b0381165f90815260036020526040902080545f190190555b6001600160a01b038516156117bb576001600160a01b0385165f908152600360205260409020805460010190555b5f8481526002602052604080822080546001600160a01b0319166001600160a01b0389811691821790925591518793918516917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4949350505050565b5f60125f8154611828906122db565b9182905550601154604080514460208201526001600160a01b03861691810191909152606081018390529192505f91608001604051602081830303815290604052805190602001205f1c61187c91906123de565b90505f805b600860ff821610156119195760108160ff16600881106118a3576118a36123fd565b601091828204019190066002029054906101000a900461ffff1661ffff168310156118d057809150611919565b60108160ff16600881106118e6576118e66123fd565b601091828204019190066002029054906101000a900461ffff1661ffff168361190f9190612285565b9250600101611881565b50600160108260ff1660088110611932576119326123fd565b601091828204019190066002028282829054906101000a900461ffff166119599190612411565b92506101000a81548161ffff021916908361ffff160217905550600160115f8282546119859190612285565b909155506119969050816001612298565b5f848152600f60205260409020805460ff191660ff92909216919091179055610aa08484611df4565b5f60095f81546119ce906122db565b91829055506119e090620186a06122b1565b90506119ed826001612298565b5f828152600f60205260409020805460ff191660ff92909216919091179055610b538382611df4565b6001600160a01b038316611a3f5760405163a9fbf51f60e01b81525f6004820152602401610a3d565b6001600160a01b038216611a7157604051630b61174360e31b81526001600160a01b0383166004820152602401610a3d565b6001600160a01b038381165f81815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6001600160a01b0383163b1561135a57604051630a85bd0160e11b81526001600160a01b0384169063150b7a0290611b1f908890889087908790600401612433565b6020604051808303815f875af1925050508015611b59575060408051601f3d908101601f19168201909252611b569181019061246f565b60015b611bc0573d808015611b86576040519150601f19603f3d011682016040523d82523d5f602084013e611b8b565b606091505b5080515f03611bb857604051633250574960e11b81526001600160a01b0385166004820152602401610a3d565b805160208201fd5b6001600160e01b03198116630a85bd0160e11b1461135857604051633250574960e11b81526001600160a01b0385166004820152602401610a3d565b60605f611c0883611e55565b60010190505f8167ffffffffffffffff811115611c2757611c2761210e565b6040519080825280601f01601f191660200182016040528015611c51576020820181803683370190505b5090508181016020015b5f19016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a8504945084611c5b57509392505050565b8080611ca057506001600160a01b03821615155b15611d61575f611caf846116e2565b90506001600160a01b03831615801590611cdb5750826001600160a01b0316816001600160a01b031614155b8015611cee5750611cec8184611698565b155b15611d175760405163a9fbf51f60e01b81526001600160a01b0384166004820152602401610a3d565b8115611d5f5783856001600160a01b0316826001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45b505b50505f90815260046020526040902080546001600160a01b0319166001600160a01b0392909216919091179055565b611d9b838383611f2c565b610b53576001600160a01b038316611dc957604051637e27328960e01b815260048101829052602401610a3d565b60405163177e802f60e01b81526001600160a01b038316600482015260248101829052604401610a3d565b6001600160a01b038216611e1d57604051633250574960e11b81525f6004820152602401610a3d565b5f611e2983835f611727565b90506001600160a01b03811615610b53576040516339e3563760e11b81525f6004820152602401610a3d565b5f8072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b8310611e935772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef81000000008310611ebf576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc100008310611edd57662386f26fc10000830492506010015b6305f5e1008310611ef5576305f5e100830492506008015b6127108310611f0957612710830492506004015b60648310611f1b576064830492506002015b600a83106109435760010192915050565b5f6001600160a01b03831615801590611f885750826001600160a01b0316846001600160a01b03161480611f655750611f658484611698565b80611f8857505f828152600460205260409020546001600160a01b038481169116145b949350505050565b6001600160e01b031981168114611fa5575f80fd5b50565b5f60208284031215611fb8575f80fd5b8135611fc381611f90565b9392505050565b5f5b83811015611fe4578181015183820152602001611fcc565b50505f910152565b5f8151808452612003816020860160208601611fca565b601f01601f19169290920160200192915050565b602081525f611fc36020830184611fec565b5f60208284031215612039575f80fd5b5035919050565b80356001600160a01b0381168114612056575f80fd5b919050565b5f806040838503121561206c575f80fd5b61207583612040565b946020939093013593505050565b5f805f60608486031215612095575f80fd5b61209e84612040565b92506120ac60208501612040565b9150604084013590509250925092565b5f602082840312156120cc575f80fd5b611fc382612040565b5f80604083850312156120e6575f80fd5b6120ef83612040565b915060208301358015158114612103575f80fd5b809150509250929050565b634e487b7160e01b5f52604160045260245ffd5b5f805f8060808587031215612135575f80fd5b61213e85612040565b935061214c60208601612040565b925060408501359150606085013567ffffffffffffffff8082111561216f575f80fd5b818701915087601f830112612182575f80fd5b8135818111156121945761219461210e565b604051601f8201601f19908116603f011681019083821181831017156121bc576121bc61210e565b816040528281528a60208487010111156121d4575f80fd5b826020860160208301375f60208483010152809550505050505092959194509250565b5f8060408385031215612208575f80fd5b61221183612040565b915061221f60208401612040565b90509250929050565b600181811c9082168061223c57607f821691505b60208210810361162057634e487b7160e01b5f52602260045260245ffd5b5f6020828403121561226a575f80fd5b5051919050565b634e487b7160e01b5f52601160045260245ffd5b8181038181111561094357610943612271565b60ff818116838216019081111561094357610943612271565b8082018082111561094357610943612271565b808202811582820484141761094357610943612271565b5f600182016122ec576122ec612271565b5060010190565b60ff828116828216039081111561094357610943612271565b5f815161231d818560208601611fca565b9290920192915050565b5f8084545f60018260011c9150600183168061234457607f831692505b6020808410820361236357634e487b7160e01b5f52602260045260245ffd5b818015612377576001811461238c576123b7565b60ff19861689528415158502890196506123b7565b5f8b8152602090205f5b868110156123af5781548b820152908501908301612396565b505084890196505b5050505050506123c7818561230c565b64173539b7b760d91b815260050195945050505050565b5f826123f857634e487b7160e01b5f52601260045260245ffd5b500690565b634e487b7160e01b5f52603260045260245ffd5b61ffff82811682821603908082111561242c5761242c612271565b5092915050565b6001600160a01b03858116825284166020820152604081018390526080606082018190525f9061246590830184611fec565b9695505050505050565b5f6020828403121561247f575f80fd5b8151611fc381611f9056fea26469706673582212207ac5a6e6be506a85fae21e7fe9bac8dc28def292429f10fcdae08401e7b6250964736f6c6343000818003300000000000000000000000060b9262456de011f7d15a54cdd8c48baaa8b022f00000000000000000000000057cc350b844484eac0de444526d295c90f9ccbb500000000000000000000000045e2c8a09022914ce00cfce9a93dd3fda54d8686000000000000000000000000000000000000000000000000000000000006978000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000004068747470733a2f2f617277656176652e6e65742f444d37617966577a61414e4132595a676d774b556d5f5464354e336b31356c7a52423843465048363331552f","recompiledBytecode":"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","sourceMap":"2446:74:15:-:0;1154:7005;2446:74;2475:4;1154:7005;2446:74;;;;;;;;;;;;;;;;2499:4;2446:74;;;;;;2511:3;2446:74;;;;;;;;;;;;:::i;:::-;;2554:4;2526:32;;2791:457;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1380:113:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1380:113:1;;;1454:5;1446;:13;;;;;;:::i;:::-;-1:-1:-1;1469:7:1;:17;1479:7;1469;:17;:::i;:::-;-1:-1:-1;;;;;;;;3027:30:15;;::::1;;::::0;3067;;::::1;;::::0;3107:16;::::1;;::::0;3145:15:::1;3133:27;::::0;;;3180:33:::1;::::0;3198:15;;3180:33:::1;:::i;:::-;3170:43;::::0;3223:7:::1;:18;3233:8:::0;3223:7;:18:::1;:::i;:::-;;2791:457:::0;;;;;1154:7005;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1154:7005:15;;;-1:-1:-1;1154:7005:15;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:16;-1:-1:-1;;;;;89:31:16;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:127::-;211:10;206:3;202:20;199:1;192:31;242:4;239:1;232:15;266:4;263:1;256:15;282:1509;406:6;414;422;430;438;491:3;479:9;470:7;466:23;462:33;459:53;;;508:1;505;498:12;459:53;540:9;534:16;559:31;584:5;559:31;:::i;:::-;609:5;599:15;;;633:2;680;669:9;665:18;659:25;693:33;718:7;693:33;:::i;:::-;797:2;782:18;;776:25;745:7;;-1:-1:-1;810:33:16;776:25;810:33;:::i;:::-;909:2;894:18;;888:25;957:3;942:19;;936:26;862:7;;-1:-1:-1;888:25:16;-1:-1:-1;;;;;;1011:14:16;;;1008:34;;;1038:1;1035;1028:12;1008:34;1076:6;1065:9;1061:22;1051:32;;1121:7;1114:4;1110:2;1106:13;1102:27;1092:55;;1143:1;1140;1133:12;1092:55;1172:2;1166:9;1194:2;1190;1187:10;1184:36;;;1200:18;;:::i;:::-;1275:2;1269:9;1243:2;1329:13;;-1:-1:-1;;1325:22:16;;;1349:2;1321:31;1317:40;1305:53;;;1373:18;;;1393:22;;;1370:46;1367:72;;;1419:18;;:::i;:::-;1459:10;1455:2;1448:22;1494:2;1486:6;1479:18;1534:7;1529:2;1524;1520;1516:11;1512:20;1509:33;1506:53;;;1555:1;1552;1545:12;1506:53;1577:1;1568:10;;1587:129;1601:2;1598:1;1595:9;1587:129;;;1689:10;;;1685:19;;1679:26;1658:14;;;1654:23;;1647:59;1612:10;;;;1587:129;;;1758:1;1753:2;1748;1740:6;1736:15;1732:24;1725:35;1779:6;1769:16;;;;;;;;282:1509;;;;;;;;:::o;1796:380::-;1875:1;1871:12;;;;1918;;;1939:61;;1993:4;1985:6;1981:17;1971:27;;1939:61;2046:2;2038:6;2035:14;2015:18;2012:38;2009:161;;2092:10;2087:3;2083:20;2080:1;2073:31;2127:4;2124:1;2117:15;2155:4;2152:1;2145:15;2009:161;;1796:380;;;:::o;2307:518::-;2409:2;2404:3;2401:11;2398:421;;;2445:5;2442:1;2435:16;2489:4;2486:1;2476:18;2559:2;2547:10;2543:19;2540:1;2536:27;2530:4;2526:38;2595:4;2583:10;2580:20;2577:47;;;-1:-1:-1;2618:4:16;2577:47;2673:2;2668:3;2664:12;2661:1;2657:20;2651:4;2647:31;2637:41;;2728:81;2746:2;2739:5;2736:13;2728:81;;;2805:1;2791:16;;2772:1;2761:13;2728:81;;;2732:3;;2398:421;2307:518;;;:::o;3001:1345::-;3121:10;;-1:-1:-1;;;;;3143:30:16;;3140:56;;;3176:18;;:::i;:::-;3205:97;3295:6;3255:38;3287:4;3281:11;3255:38;:::i;:::-;3249:4;3205:97;:::i;:::-;3357:4;;3414:2;3403:14;;3431:1;3426:663;;;;4133:1;4150:6;4147:89;;;-1:-1:-1;4202:19:16;;;4196:26;4147:89;-1:-1:-1;;2958:1:16;2954:11;;;2950:24;2946:29;2936:40;2982:1;2978:11;;;2933:57;4249:81;;3396:944;;3426:663;2254:1;2247:14;;;2291:4;2278:18;;-1:-1:-1;;3462:20:16;;;3580:236;3594:7;3591:1;3588:14;3580:236;;;3683:19;;;3677:26;3662:42;;3775:27;;;;3743:1;3731:14;;;;3610:19;;3580:236;;;3584:3;3844:6;3835:7;3832:19;3829:201;;;3905:19;;;3899:26;-1:-1:-1;;3988:1:16;3984:14;;;4000:3;3980:24;3976:37;3972:42;3957:58;3942:74;;3829:201;;;4076:1;4067:6;4064:1;4060:14;4056:22;4050:4;4043:36;3396:944;;;;;3001:1345;;:::o;4351:222::-;4416:9;;;4437:10;;;4434:133;;;4489:10;4484:3;4480:20;4477:1;4470:31;4524:4;4521:1;4514:15;4552:4;4549:1;4542:15;4434:133;4351:222;;;;:::o;:::-;1154:7005:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212207ac5a6e6be506a85fae21e7fe9bac8dc28def292429f10fcdae08401e7b6250964736f6c63430008180033","offset":10678}},"transformations":[{"type":"insert","offset":10731,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x00000000000000000000000060b9262456de011f7d15a54cdd8c48baaa8b022f00000000000000000000000057cc350b844484eac0de444526d295c90f9ccbb500000000000000000000000045e2c8a09022914ce00cfce9a93dd3fda54d8686000000000000000000000000000000000000000000000000000000000006978000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000004068747470733a2f2f617277656176652e6e65742f444d37617966577a61414e4132595a676d774b556d5f5464354e336b31356c7a52423843465048363331552f"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1154:7005:15:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1527:300:1;;;;;;;;;;-1:-1:-1;1527:300:1;;;;;:::i;:::-;;:::i;:::-;;;565:14:16;;558:22;540:41;;528:2;513:18;1527:300:1;;;;;;;;2263:89;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3299:154::-;;;;;;;;;;-1:-1:-1;3299:154:1;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1719:32:16;;;1701:51;;1689:2;1674:18;3299:154:1;1555:203:16;3152:113:1;;;;;;;;;;-1:-1:-1;3152:113:1;;;;;:::i;:::-;;:::i;:::-;;1692:38:15;;;;;;;;;;;;1729:1;1692:38;;;;;2372:4:16;2360:17;;;2342:36;;2330:2;2315:18;1692:38:15;2200:184:16;4184:52:15;;;;;;;;;;;;;:::i;3852:578:1:-;;;;;;;;;;-1:-1:-1;3852:578:1;;;;;:::i;:::-;;:::i;1985:34:15:-;;;;;;;;;;;;;;;;;;2868:25:16;;;2856:2;2841:18;1985:34:15;2722:177:16;1547:45:15;;;;;;;;;;;;1580:12;1547:45;;2123:25;;;;;;;;;;;;;;;;2154;;;;;;;;;;;;;;;;2349:41;;;;;;;;;;-1:-1:-1;2349:41:15;;;;;:::i;:::-;;;;;;;;;;;;;;5442:121;;;;;;;;;;-1:-1:-1;5442:121:15;;;;;:::i;:::-;;:::i;2301:42::-;;;;;;;;;;-1:-1:-1;2301:42:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;4464:132:1;;;;;;;;;;-1:-1:-1;4464:132:1;;;;;:::i;:::-;;:::i;1221:39:15:-;;;;;;;;;;;;1256:4;1221:39;;2221:26;;;;;;;;;;;;;;;;3466:647;;;;;;;;;;;;;:::i;2103:118:1:-;;;;;;;;;;-1:-1:-1;2103:118:1;;;;;:::i;:::-;;:::i;1940:39:15:-;;;;;;;;;;;;;;;4242:1157;;;;;;:::i;:::-;;:::i;2446:74::-;;;;;;;;;;-1:-1:-1;2446:74:15;;;;;:::i;:::-;;:::i;:::-;;;3493:6:16;3481:19;;;3463:38;;3451:2;3436:18;2446:74:15;3319:188:16;1861:208:1;;;;;;;;;;-1:-1:-1;1861:208:1;;;;;:::i;:::-;;:::i;1899:35:15:-;;;;;;;;;;;;;;;6222:704;;;;;;;;;;-1:-1:-1;6222:704:15;;;;;:::i;:::-;;:::i;:::-;;;;4008:25:16;;;4064:2;4049:18;;4042:34;;;;4092:18;;;4085:34;;;;4162:14;4155:22;4150:2;4135:18;;4128:50;4222:14;4215:22;4209:3;4194:19;;4187:51;4282:14;4275:22;4269:3;4254:19;;4247:51;3995:3;3980:19;6222:704:15;3739:565:16;2253:42:15;;;;;;;;;;-1:-1:-1;2253:42:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;2394:93:1;;;;;;;;;;;;;:::i;5778:114:15:-;;;;;;;;;;-1:-1:-1;5778:114:15;;;;;:::i;:::-;;:::i;2185:30::-;;;;;;;;;;;;;;;;1598:45;;;;;;;;;;;;1631:12;1598:45;;3487:144:1;;;;;;;;;;-1:-1:-1;3487:144:1;;;;;:::i;:::-;;:::i;6932:102:15:-;;;;;;;;;;;;;:::i;1501:40::-;;;;;;;;;;;;1537:4;1501:40;;1360:43;;;;;;;;;;;;1402:1;1360:43;;4630:233:1;;;;;;;;;;-1:-1:-1;4630:233:1;;;;;:::i;:::-;;:::i;5972:148:15:-;;;;;;;;;;-1:-1:-1;5972:148:15;;;;;:::i;:::-;;:::i;7209:126::-;;;;;;;;;;-1:-1:-1;7209:126:15;;;;;:::i;:::-;;:::i;7040:163::-;;;;;;;;;;-1:-1:-1;7040:163:15;;;;;:::i;:::-;;:::i;6126:90::-;;;;;;;;;;;;;:::i;1311:43::-;;;;;;;;;;;;1353:1;1311:43;;2092:25;;;;;;;;;;;;;;;;1409:44;;;;;;;;;;;;1451:2;1409:44;;1459:36;;;;;;;;;;;;1493:2;1459:36;;1736:39;;;;;;;;;;;;1774:1;1736:39;;1858:35;;;;;;;;;;;;;;;3665:153:1;;;;;;;;;;-1:-1:-1;3665:153:1;;;;;:::i;:::-;;:::i;2025:32:15:-;;;;;;;;;;;;;;;5569:152;;;;;;;;;;-1:-1:-1;5569:152:15;;;;;:::i;:::-;;:::i;1266:39::-;;;;;;;;;;;;1301:4;1266:39;;1527:300:1;1629:4;-1:-1:-1;;;;;;1664:40:1;;-1:-1:-1;;;1664:40:1;;:104;;-1:-1:-1;;;;;;;1720:48:1;;-1:-1:-1;;;1720:48:1;1664:104;:156;;;-1:-1:-1;;;;;;;;;;829:40:10;;;1784:36:1;1645:175;1527:300;-1:-1:-1;;1527:300:1:o;2263:89::-;2308:13;2340:5;2333:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2263:89;:::o;3299:154::-;3366:7;3385:22;3399:7;3385:13;:22::i;:::-;-1:-1:-1;5679:7:1;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;5705:24:1;3425:21;5609:127;3152:113;3223:35;3232:2;3236:7;735:10:7;3223:8:1;:35::i;:::-;3152:113;;:::o;4184:52:15:-;4219:10;:8;:10::i;:::-;4184:52::o;3852:578:1:-;-1:-1:-1;;;;;3946:16:1;;3942:87;;3985:33;;-1:-1:-1;;;3985:33:1;;4015:1;3985:33;;;1701:51:16;1674:18;;3985:33:1;;;;;;;;3942:87;4247:21;4271:34;4279:2;4283:7;735:10:7;4271:7:1;:34::i;:::-;4247:58;;4336:4;-1:-1:-1;;;;;4319:21:1;:13;-1:-1:-1;;;;;4319:21:1;;4315:109;;4363:50;;-1:-1:-1;;;4363:50:1;;-1:-1:-1;;;;;6844:15:16;;;4363:50:1;;;6826:34:16;6876:18;;;6869:34;;;6939:15;;6919:18;;;6912:43;6761:18;;4363:50:1;6586:375:16;4315:109:1;3932:498;3852:578;;;:::o;5442:121:15:-;5527:25;;-1:-1:-1;;;5527:25:15;;-1:-1:-1;;;;;1719:32:16;;;5527:25:15;;;1701:51:16;5504:4:15;;;;5527:7;:17;;;;1674:18:16;;5527:25:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:29;;5442:121;-1:-1:-1;;5442:121:15:o;4464:132:1:-;4550:39;4567:4;4573:2;4577:7;4550:39;;;;;;;;;;;;:16;:39::i;:::-;4464:132;;;:::o;3466:647:15:-;3310:7;3292:15;:25;3284:48;;;;-1:-1:-1;;;3284:48:15;;7357:2:16;3284:48:15;;;7339:21:16;7396:2;7376:18;;;7369:30;-1:-1:-1;;;7415:18:16;;;7408:40;7465:18;;3284:48:15;7155:334:16;3284:48:15;3350:29;;-1:-1:-1;;;3350:29:15;;3368:10;3350:29;;;1701:51:16;3382:1:15;;3350:7;-1:-1:-1;;;;;3350:17:15;;;;1674:18:16;;3350:29:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;3342:63;;;;-1:-1:-1;;;3342:63:15;;7696:2:16;3342:63:15;;;7678:21:16;7735:2;7715:18;;;7708:30;-1:-1:-1;;;7754:18:16;;;7747:47;7811:18;;3342:63:15;7494:341:16;3342:63:15;3512:13:::1;3528:25;3542:10;3528:13;:25::i;:::-;3596:10;3563:12;3586:21:::0;;;:9:::1;:21;::::0;;;;;3512:41;;-1:-1:-1;3563:12:15;3586:21:::1;;3578:29:::0;::::1;:65;;3642:1;3578:65;;;3628:10;3618:21;::::0;;;:9:::1;:21;::::0;;;;;3610:29:::1;::::0;3618:21:::1;;3610:5:::0;:29:::1;:::i;:::-;3563:80;;3668:1;3661:4;:8;3653:30;;;::::0;-1:-1:-1;;;3653:30:15;;8307:2:16;3653:30:15::1;::::0;::::1;8289:21:16::0;8346:1;8326:18;;;8319:29;-1:-1:-1;;;8364:18:16;;;8357:39;8413:18;;3653:30:15::1;8105:332:16::0;3653:30:15::1;3693:18;3725:10;;1256:4;3714:21;;;;:::i;:::-;3693:42;;3766:1;3753:10;:14;3745:40;;;::::0;-1:-1:-1;;;3745:40:15;;8644:2:16;3745:40:15::1;::::0;::::1;8626:21:16::0;8683:2;8663:18;;;8656:30;-1:-1:-1;;;8702:18:16;;;8695:43;8755:18;;3745:40:15::1;8442:337:16::0;3745:40:15::1;3806:10;3799:4;:17;3795:40;;;3825:10;3818:17;;3795:40;3855:10;3845:21;::::0;;;:9:::1;:21;::::0;;;;:36;;3876:4;;3845:21;:36:::1;::::0;3876:4;;3845:36:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;3905:4;3891:10;;:18;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;3926:10:15::1;3919:18;::::0;;;:6:::1;:18;::::0;;;;:26;;3941:4;;3919:18;:26:::1;::::0;3941:4;;3919:26:::1;:::i;:::-;;;;;;;;3970:4;3955:11;;:19;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;3989:9:15::1;::::0;-1:-1:-1;3984:53:15::1;4004:4;4000:1;:8;3984:53;;;4015:22;4026:10;4015;:22::i;:::-;4010:3;;3984:53;;;-1:-1:-1::0;4052:54:15::1;::::0;;9235:25:16;;;1402:1:15::1;4081:24:::0;::::1;9291:2:16::0;9276:18;;9269:50;4063:10:15::1;::::0;4052:54:::1;::::0;9208:18:16;4052:54:15::1;;;;;;;3502:611;;;3466:647::o:0;2103:118:1:-;2166:7;2192:22;2206:7;2192:13;:22::i;4242:1157:15:-;3310:7;3292:15;:25;3284:48;;;;-1:-1:-1;;;3284:48:15;;7357:2:16;3284:48:15;;;7339:21:16;7396:2;7376:18;;;7369:30;-1:-1:-1;;;7415:18:16;;;7408:40;7465:18;;3284:48:15;7155:334:16;3284:48:15;3350:29;;-1:-1:-1;;;3350:29:15;;3368:10;3350:29;;;1701:51:16;3382:1:15;;3350:7;-1:-1:-1;;;;;3350:17:15;;;;1674:18:16;;3350:29:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;3342:63;;;;-1:-1:-1;;;3342:63:15;;7696:2:16;3342:63:15;;;7678:21:16;7735:2;7715:18;;;7708:30;-1:-1:-1;;;7754:18:16;;;7747:47;7811:18;;3342:63:15;7494:341:16;3342:63:15;4323:1:::1;4317:3;:7;4309:25;;;::::0;-1:-1:-1;;;4309:25:15;;9532:2:16;4309:25:15::1;::::0;::::1;9514:21:16::0;9571:1;9551:18;;;9544:29;-1:-1:-1;;;9589:18:16;;;9582:35;9634:18;;4309:25:15::1;9330:328:16::0;4309:25:15::1;4362:10;4352:21;::::0;;;:9:::1;:21;::::0;;;;;1451:2:::1;::::0;4352:27:::1;::::0;4376:3;;4352:21:::1;;:27;:::i;:::-;:46;;4344:70;;;::::0;-1:-1:-1;;;4344:70:15;;9865:2:16;4344:70:15::1;::::0;::::1;9847:21:16::0;9904:2;9884:18;;;9877:30;-1:-1:-1;;;9923:18:16;;;9916:41;9974:18;;4344:70:15::1;9663:335:16::0;4344:70:15::1;1301:4;4445:3;4432:10;;:16;;;;:::i;:::-;:28;;4424:54;;;::::0;-1:-1:-1;;;4424:54:15;;10205:2:16;4424:54:15::1;::::0;::::1;10187:21:16::0;10244:2;10224:18;;;10217:30;-1:-1:-1;;;10263:18:16;;;10256:43;10316:18;;4424:54:15::1;10003:337:16::0;4424:54:15::1;4488:12;4503;4511:3;4503:7;:12::i;:::-;4488:27;;4546:4;4533:9;:17;;4525:39;;;::::0;-1:-1:-1;;;4525:39:15;;10547:2:16;4525:39:15::1;::::0;::::1;10529:21:16::0;10586:1;10566:18;;;10559:29;-1:-1:-1;;;10604:18:16;;;10597:39;10653:18;;4525:39:15::1;10345:332:16::0;4525:39:15::1;4602:10;4575:14;4592:21:::0;;;:9:::1;:21;::::0;;;;;;::::1;;::::0;4654:3;;4592:21;4623:35:::1;4654:3:::0;4592:21;4623:35:::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;4682:3;4668:10;;:17;;;;;;;:::i;:::-;;;;;;;;4714:4;4695:15;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;4750:7:15::1;::::0;-1:-1:-1;4754:3:15;4750:1:::1;:7;:::i;:::-;4735:10;4728:18;::::0;;;:6:::1;:18;::::0;;;;:29;;:18;;;:29:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;4782:7:15::1;::::0;-1:-1:-1;4786:3:15;4782:1:::1;:7;:::i;:::-;4767:11;;:22;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;4804:9:15::1;::::0;-1:-1:-1;4799:52:15::1;4819:3;4815:1;:7;4799:52;;;4829:22;4840:10;4829;:22::i;:::-;4824:3;;4799:52;;;;1493:2;4866:6;:16;:43;;;;-1:-1:-1::0;1493:2:15::1;4886:12;4895:3:::0;4886:6;:12:::1;:::i;:::-;:23;;4866:43;4862:202;;;4925:35;4935:10;1729:1;4925:9;:35::i;:::-;4974:36;4984:10;1774:1;4974:9;:36::i;:::-;5029:24;::::0;5042:10:::1;::::0;5029:24:::1;::::0;;;::::1;4862:202;5078:33;::::0;;11029:25:16;;;11085:2;11070:18;;11063:34;;;5089:10:15::1;::::0;5078:33:::1;::::0;11002:18:16;5078:33:15::1;;;;;;;5123:7;5136:6;-1:-1:-1::0;;;;;5136:11:15::1;5155:4;5136:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5122:42;;;5182:2;5174:28;;;::::0;-1:-1:-1;;;5174:28:15;;11520:2:16;5174:28:15::1;::::0;::::1;11502:21:16::0;11559:2;11539:18;;;11532:30;-1:-1:-1;;;11578:18:16;;;11571:43;11631:18;;5174:28:15::1;11318:337:16::0;5174:28:15::1;5212:14;5229:16;5241:4:::0;5229:9:::1;:16;:::i;:::-;5212:33:::0;-1:-1:-1;5259:10:15;;5255:138:::1;;5298:43;::::0;5286:6:::1;::::0;5306:10:::1;::::0;5330:6;;5286;5298:43;5286:6;5298:43;5330:6;5306:10;5298:43:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5285:56;;;5363:1;5355:27;;;::::0;-1:-1:-1;;;5355:27:15;;11862:2:16;5355:27:15::1;::::0;::::1;11844:21:16::0;11901:2;11881:18;;;11874:30;-1:-1:-1;;;11920:18:16;;;11913:43;11973:18;;5355:27:15::1;11660:337:16::0;5355:27:15::1;5271:122;5255:138;4299:1100;;;;4242:1157:::0;:::o;2446:74::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1861:208:1:-;1924:7;-1:-1:-1;;;;;1947:19:1;;1943:87;;1989:30;;-1:-1:-1;;;1989:30:1;;2016:1;1989:30;;;1701:51:16;1674:18;;1989:30:1;1555:203:16;1943:87:1;-1:-1:-1;;;;;;2046:16:1;;;;;:9;:16;;;;;;;1861:208::o;6222:704:15:-;6313:16;6331;6349:12;6363:13;6378:9;6389:11;6416:13;6432:21;6446:6;6432:13;:21::i;:::-;-1:-1:-1;;;;;6484:17:15;;6463:10;6484:17;;;:9;:17;;;;;;6416:37;;-1:-1:-1;6463:10:15;6484:17;;6476:25;;:57;;6532:1;6476:57;;;-1:-1:-1;;;;;6512:17:15;;;;;;:9;:17;;;;;;6504:25;;6512:17;;6504:5;:25;:::i;:::-;6463:70;;6543:10;6567;;1256:4;6556:21;;;;:::i;:::-;6543:34;;6603:2;6598;:7;:17;;6613:2;6598:17;;;6608:2;6598:17;-1:-1:-1;;;;;6656:17:15;;6625:10;6656:17;;;:9;:17;;;;;;6587:28;;-1:-1:-1;6625:10:15;6638:35;;6656:17;;1451:2;6638:35;:::i;:::-;6625:48;;6683:10;6707;;1301:4;6696:21;;;;:::i;:::-;6683:34;;6743:2;6738;:7;:17;;6753:2;6738:17;;;6748:2;6738:17;6727:28;;6772:12;6780:3;6772:7;:12::i;:::-;6805:25;;-1:-1:-1;;;6805:25:15;;-1:-1:-1;;;;;1719:32:16;;;6805:25:15;;;1701:51:16;6765:19:15;;-1:-1:-1;6833:1:15;;6805:7;:17;;;;1674:18:16;;6805:25:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:29;6794:40;;6869:7;6851:15;:25;6844:32;;1402:1;6895:5;:24;6886:33;;6406:520;;;;;6222:704;;;;;;;;:::o;2394:93:1:-;2441:13;2473:7;2466:14;;;;;:::i;5778:114:15:-;5827:7;1537:4;5853:1;:14;;:32;;1631:12;5853:32;;;1580:12;5846:39;5778:114;-1:-1:-1;;5778:114:15:o;3487:144:1:-;3572:52;735:10:7;3605:8:1;3615;3572:18;:52::i;6932:102:15:-;6978:7;7017:10;;7004;;:23;;;;:::i;:::-;6997:30;;6932:102;:::o;4630:233:1:-;4743:31;4756:4;4762:2;4766:7;4743:12;:31::i;:::-;4784:72;735:10:7;4832:4:1;4838:2;4842:7;4851:4;4784:33;:72::i;5972:148:15:-;6023:12;6064:1;6047:66;6072:3;6067:1;:8;6047:66;;6090:23;6111:1;6098:10;;:14;;;;:::i;6090:23::-;6082:31;;;;:::i;:::-;;-1:-1:-1;6077:3:15;;;:::i;:::-;;;6047:66;;;;5972:148;;;:::o;7209:126::-;7259:5;7276:17;7290:2;7276:13;:17::i;:::-;-1:-1:-1;7310:14:15;;;;:10;:14;;;;;;:18;;7327:1;;7310:14;;:18;:::i;7040:163::-;7100:13;7146:7;7155:31;7163:11;7171:2;7163:7;:11::i;:::-;7155:20;;:29;:31::i;:::-;7132:64;;;;;;;;;:::i;:::-;;;;;;;;;;;;;7125:71;;7040:163;;;:::o;6126:90::-;6173:7;6199:10;6207:1;6199:7;:10::i;3665:153:1:-;-1:-1:-1;;;;;3776:25:1;;;3753:4;3776:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;3665:153::o;5569:152:15:-;5629:7;5655:23;5671:6;5655:15;:23::i;:::-;:59;;1353:1;5655:59;;;1402:1;5648:66;5569:152;-1:-1:-1;;5569:152:15:o;15957:241:1:-;16020:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:1;;16082:88;;16128:31;;-1:-1:-1;;;16128:31:1;;;;;2868:25:16;;;2841:18;;16128:31:1;2722:177:16;14138:120:1;14218:33;14227:2;14231:7;14240:4;14246;14218:8;:33::i;8507:795::-;8593:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:1;;;;8704:18;;;8700:86;;8738:37;8755:4;8761;8767:7;8738:16;:37::i;:::-;-1:-1:-1;;;;;8830:18:1;;;8826:256;;8946:48;8963:1;8967:7;8984:1;8988:5;8946:8;:48::i;:::-;-1:-1:-1;;;;;9037:15:1;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9037:20:1;;;8826:256;-1:-1:-1;;;;;9096:16:1;;;9092:107;;-1:-1:-1;;;;;9156:13:1;;;;;;:9;:13;;;;;:18;;9173:1;9156:18;;;9092:107;9209:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9209:21:1;-1:-1:-1;;;;;9209:21:1;;;;;;;;;9246:27;;9209:16;;9246:27;;;;;;;9291:4;8507:795;-1:-1:-1;;;;8507:795:1:o;7500:470:15:-;7551:15;7571:7;;7569:9;;;;;:::i;:::-;;;;;-1:-1:-1;7667:9:15;;7621:41;;;7632:16;7621:41;;;14266:25:16;-1:-1:-1;;;;;14327:32:16;;14307:18;;;14300:60;;;;14376:18;;;14369:34;;;7569:9:15;;-1:-1:-1;7588:12:15;;14239:18:16;;7621:41:15;;;;;;;;;;;;7611:52;;;;;;7603:61;;:73;;;;:::i;:::-;7588:88;;7686:10;7711:7;7706:137;1685:1;7720:15;;;;7706:137;;;7767:8;7776:1;7767:11;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;7760:18;;:4;:18;7756:44;;;7789:1;7782:8;;7792:5;;7756:44;7821:8;7830:1;7821:11;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;7813:19;;;;;;;:::i;:::-;;-1:-1:-1;7737:3:15;;7706:137;;;;7870:1;7852:8;7861:4;7852:14;;;;;;;;;:::i;:::-;;;;;;;;;;;;:19;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;7894:1;7881:9;;:14;;;;;;;:::i;:::-;;;;-1:-1:-1;7927:8:15;;-1:-1:-1;7927:4:15;7934:1;7927:8;:::i;:::-;7905:19;;;;:10;:19;;;;;:30;;-1:-1:-1;;7905:30:15;;;;;;;;;;;;7945:18;7951:2;7905:19;7945:5;:18::i;7976:181::-;8038:15;8071:10;;8069:12;;;;;:::i;:::-;;;;;-1:-1:-1;8056:26:15;;1818:6;8056:26;:::i;:::-;8038:44;-1:-1:-1;8114:8:15;:4;8121:1;8114:8;:::i;:::-;8092:19;;;;:10;:19;;;;;:30;;-1:-1:-1;;8092:30:15;;;;;;;;;;;;8132:18;8138:2;8092:19;8132:5;:18::i;15311:411:1:-;-1:-1:-1;;;;;15418:19:1;;15414:90;;15460:33;;-1:-1:-1;;;15460:33:1;;15490:1;15460:33;;;1701:51:16;1674:18;;15460:33:1;1555:203:16;15414:90:1;-1:-1:-1;;;;;15517:22:1;;15513:91;;15562:31;;-1:-1:-1;;;15562:31:1;;-1:-1:-1;;;;;1719:32:16;;15562:31:1;;;1701:51:16;1674:18;;15562:31:1;1555:203:16;15513:91:1;-1:-1:-1;;;;;15613:25:1;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;15613:46:1;;;;;;;;;;15674:41;;540::16;;;15674::1;;513:18:16;15674:41:1;;;;;;;15311:411;;;:::o;994:926:5:-;-1:-1:-1;;;;;1174:14:5;;;:18;1170:744;;1212:67;;-1:-1:-1;;;1212:67:5;;-1:-1:-1;;;;;1212:36:5;;;;;:67;;1249:8;;1259:4;;1265:7;;1274:4;;1212:67;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1212:67:5;;;;;;;;-1:-1:-1;;1212:67:5;;;;;;;;;;;;:::i;:::-;;;1208:696;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1569:6;:13;1586:1;1569:18;1565:325;;1673:39;;-1:-1:-1;;;1673:39:5;;-1:-1:-1;;;;;1719:32:16;;1673:39:5;;;1701:51:16;1674:18;;1673:39:5;1555:203:16;1565:325:5;1842:6;1836:13;1829:4;1821:6;1817:17;1810:40;1208:696;-1:-1:-1;;;;;;1326:51:5;;-1:-1:-1;;;1326:51:5;1322:182;;1446:39;;-1:-1:-1;;;1446:39:5;;-1:-1:-1;;;;;1719:32:16;;1446:39:5;;;1701:51:16;1674:18;;1446:39:5;1555:203:16;1251:634:9;1307:13;1356:14;1373:17;1384:5;1373:10;:17::i;:::-;1393:1;1373:21;1356:38;;1408:20;1442:6;1431:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1431:18:9;-1:-1:-1;1408:41:9;-1:-1:-1;1538:30:9;;;1554:4;1538:30;1595:247;-1:-1:-1;;1626:5:9;-1:-1:-1;;;1725:2:9;1714:14;;1709:32;1626:5;1696:46;1786:2;1777:11;;;-1:-1:-1;1806:21:9;1595:247;1806:21;-1:-1:-1;1862:6:9;1251:634;-1:-1:-1;;;1251:634:9:o;14440:662:1:-;14600:9;:31;;;-1:-1:-1;;;;;;14613:18:1;;;;14600:31;14596:460;;;14647:13;14663:22;14677:7;14663:13;:22::i;:::-;14647:38;-1:-1:-1;;;;;;14813:18:1;;;;;;:35;;;14844:4;-1:-1:-1;;;;;14835:13:1;:5;-1:-1:-1;;;;;14835:13:1;;;14813:35;:69;;;;;14853:29;14870:5;14877:4;14853:16;:29::i;:::-;14852:30;14813:69;14809:142;;;14909:27;;-1:-1:-1;;;14909:27:1;;-1:-1:-1;;;;;1719:32:16;;14909:27:1;;;1701:51:16;1674:18;;14909:27:1;1555:203:16;14809:142:1;14969:9;14965:81;;;15023:7;15019:2;-1:-1:-1;;;;;15003:28:1;15012:5;-1:-1:-1;;;;;15003:28:1;;;;;;;;;;;14965:81;14633:423;14596:460;-1:-1:-1;;15066:24:1;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15066:29:1;-1:-1:-1;;;;;15066:29:1;;;;;;;;;;14440:662::o;6751:368::-;6863:38;6877:5;6884:7;6893;6863:13;:38::i;:::-;6858:255;;-1:-1:-1;;;;;6921:19:1;;6917:186;;6967:31;;-1:-1:-1;;;6967:31:1;;;;;2868:25:16;;;2841:18;;6967:31:1;2722:177:16;6917:186:1;7044:44;;-1:-1:-1;;;7044:44:1;;-1:-1:-1;;;;;16019:32:16;;7044:44:1;;;16001:51:16;16068:18;;;16061:34;;;15974:18;;7044:44:1;15827:274:16;9624:327:1;-1:-1:-1;;;;;9691:16:1;;9687:87;;9730:33;;-1:-1:-1;;;9730:33:1;;9760:1;9730:33;;;1701:51:16;1674:18;;9730:33:1;1555:203:16;9687:87:1;9783:21;9807:32;9815:2;9819:7;9836:1;9807:7;:32::i;:::-;9783:56;-1:-1:-1;;;;;;9853:27:1;;;9849:96;;9903:31;;-1:-1:-1;;;9903:31:1;;9931:1;9903:31;;;1701:51:16;1674:18;;9903:31:1;1555:203:16;29471:916:12;29524:7;;-1:-1:-1;;;29599:17:12;;29595:103;;-1:-1:-1;;;29636:17:12;;;-1:-1:-1;29681:2:12;29671:12;29595:103;29724:8;29715:5;:17;29711:103;;29761:8;29752:17;;;-1:-1:-1;29797:2:12;29787:12;29711:103;29840:8;29831:5;:17;29827:103;;29877:8;29868:17;;;-1:-1:-1;29913:2:12;29903:12;29827:103;29956:7;29947:5;:16;29943:100;;29992:7;29983:16;;;-1:-1:-1;30027:1:12;30017:11;29943:100;30069:7;30060:5;:16;30056:100;;30105:7;30096:16;;;-1:-1:-1;30140:1:12;30130:11;30056:100;30182:7;30173:5;:16;30169:100;;30218:7;30209:16;;;-1:-1:-1;30253:1:12;30243:11;30169:100;30295:7;30286:5;:16;30282:66;;30332:1;30322:11;30374:6;29471:916;-1:-1:-1;;29471:916:12:o;6047:272:1:-;6150:4;-1:-1:-1;;;;;6185:21:1;;;;;;:127;;;6232:7;-1:-1:-1;;;;;6223:16:1;:5;-1:-1:-1;;;;;6223:16:1;;:52;;;;6243:32;6260:5;6267:7;6243:16;:32::i;:::-;6223:88;;;-1:-1:-1;5679:7:1;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6279:32:1;;;5705:24;;6279:32;6223:88;6166:146;6047:272;-1:-1:-1;;;;6047:272:1:o;14:131:16:-;-1:-1:-1;;;;;;88:32:16;;78:43;;68:71;;135:1;132;125:12;68:71;14:131;:::o;150:245::-;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;:::-;384:5;150:245;-1:-1:-1;;;150:245:16:o;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:16;816:16;;809:27;592:250::o;847:282::-;900:3;938:5;932:12;965:6;960:3;953:19;981:76;1050:6;1043:4;1038:3;1034:14;1027:4;1020:5;1016:16;981:76;:::i;:::-;1111:2;1090:15;-1:-1:-1;;1086:29:16;1077:39;;;;1118:4;1073:50;;847:282;-1:-1:-1;;847:282:16:o;1134:231::-;1283:2;1272:9;1265:21;1246:4;1303:56;1355:2;1344:9;1340:18;1332:6;1303:56;:::i;1370:180::-;1429:6;1482:2;1470:9;1461:7;1457:23;1453:32;1450:52;;;1498:1;1495;1488:12;1450:52;-1:-1:-1;1521:23:16;;1370:180;-1:-1:-1;1370:180:16:o;1763:173::-;1831:20;;-1:-1:-1;;;;;1880:31:16;;1870:42;;1860:70;;1926:1;1923;1916:12;1860:70;1763:173;;;:::o;1941:254::-;2009:6;2017;2070:2;2058:9;2049:7;2045:23;2041:32;2038:52;;;2086:1;2083;2076:12;2038:52;2109:29;2128:9;2109:29;:::i;:::-;2099:39;2185:2;2170:18;;;;2157:32;;-1:-1:-1;;;1941:254:16:o;2389:328::-;2466:6;2474;2482;2535:2;2523:9;2514:7;2510:23;2506:32;2503:52;;;2551:1;2548;2541:12;2503:52;2574:29;2593:9;2574:29;:::i;:::-;2564:39;;2622:38;2656:2;2645:9;2641:18;2622:38;:::i;:::-;2612:48;;2707:2;2696:9;2692:18;2679:32;2669:42;;2389:328;;;;;:::o;2904:186::-;2963:6;3016:2;3004:9;2995:7;2991:23;2987:32;2984:52;;;3032:1;3029;3022:12;2984:52;3055:29;3074:9;3055:29;:::i;4309:347::-;4374:6;4382;4435:2;4423:9;4414:7;4410:23;4406:32;4403:52;;;4451:1;4448;4441:12;4403:52;4474:29;4493:9;4474:29;:::i;:::-;4464:39;;4553:2;4542:9;4538:18;4525:32;4600:5;4593:13;4586:21;4579:5;4576:32;4566:60;;4622:1;4619;4612:12;4566:60;4645:5;4635:15;;;4309:347;;;;;:::o;4661:127::-;4722:10;4717:3;4713:20;4710:1;4703:31;4753:4;4750:1;4743:15;4777:4;4774:1;4767:15;4793:1138;4888:6;4896;4904;4912;4965:3;4953:9;4944:7;4940:23;4936:33;4933:53;;;4982:1;4979;4972:12;4933:53;5005:29;5024:9;5005:29;:::i;:::-;4995:39;;5053:38;5087:2;5076:9;5072:18;5053:38;:::i;:::-;5043:48;;5138:2;5127:9;5123:18;5110:32;5100:42;;5193:2;5182:9;5178:18;5165:32;5216:18;5257:2;5249:6;5246:14;5243:34;;;5273:1;5270;5263:12;5243:34;5311:6;5300:9;5296:22;5286:32;;5356:7;5349:4;5345:2;5341:13;5337:27;5327:55;;5378:1;5375;5368:12;5327:55;5414:2;5401:16;5436:2;5432;5429:10;5426:36;;;5442:18;;:::i;:::-;5517:2;5511:9;5485:2;5571:13;;-1:-1:-1;;5567:22:16;;;5591:2;5563:31;5559:40;5547:53;;;5615:18;;;5635:22;;;5612:46;5609:72;;;5661:18;;:::i;:::-;5701:10;5697:2;5690:22;5736:2;5728:6;5721:18;5776:7;5771:2;5766;5762;5758:11;5754:20;5751:33;5748:53;;;5797:1;5794;5787:12;5748:53;5853:2;5848;5844;5840:11;5835:2;5827:6;5823:15;5810:46;5898:1;5893:2;5888;5880:6;5876:15;5872:24;5865:35;5919:6;5909:16;;;;;;;4793:1138;;;;;;;:::o;5936:260::-;6004:6;6012;6065:2;6053:9;6044:7;6040:23;6036:32;6033:52;;;6081:1;6078;6071:12;6033:52;6104:29;6123:9;6104:29;:::i;:::-;6094:39;;6152:38;6186:2;6175:9;6171:18;6152:38;:::i;:::-;6142:48;;5936:260;;;;;:::o;6201:380::-;6280:1;6276:12;;;;6323;;;6344:61;;6398:4;6390:6;6386:17;6376:27;;6344:61;6451:2;6443:6;6440:14;6420:18;6417:38;6414:161;;6497:10;6492:3;6488:20;6485:1;6478:31;6532:4;6529:1;6522:15;6560:4;6557:1;6550:15;6966:184;7036:6;7089:2;7077:9;7068:7;7064:23;7060:32;7057:52;;;7105:1;7102;7095:12;7057:52;-1:-1:-1;7128:16:16;;6966:184;-1:-1:-1;6966:184:16:o;7840:127::-;7901:10;7896:3;7892:20;7889:1;7882:31;7932:4;7929:1;7922:15;7956:4;7953:1;7946:15;7972:128;8039:9;;;8060:11;;;8057:37;;;8074:18;;:::i;8784:148::-;8872:4;8851:12;;;8865;;;8847:31;;8890:13;;8887:39;;;8906:18;;:::i;8937:125::-;9002:9;;;9023:10;;;9020:36;;;9036:18;;:::i;10682:168::-;10755:9;;;10786;;10803:15;;;10797:22;;10783:37;10773:71;;10824:18;;:::i;12002:135::-;12041:3;12062:17;;;12059:43;;12082:18;;:::i;:::-;-1:-1:-1;12129:1:16;12118:13;;12002:135::o;12142:151::-;12232:4;12225:12;;;12211;;;12207:31;;12250:14;;12247:40;;;12267:18;;:::i;12424:198::-;12466:3;12504:5;12498:12;12519:65;12577:6;12572:3;12565:4;12558:5;12554:16;12519:65;:::i;:::-;12600:16;;;;;12424:198;-1:-1:-1;;12424:198:16:o;12699:1360::-;12965:3;12994:1;13027:6;13021:13;13057:1;13077;13104:9;13101:1;13097:17;13087:27;;13164:1;13153:9;13149:17;13185:18;13175:61;;13229:4;13221:6;13217:17;13207:27;;13175:61;13255:2;13303;13295:6;13292:14;13272:18;13269:38;13266:161;;13349:10;13344:3;13340:20;13337:1;13330:31;13384:4;13381:1;13374:15;13412:4;13409:1;13402:15;13266:161;13443:18;13470:133;;;;13617:1;13612:320;;;;13436:496;;13470:133;-1:-1:-1;;13503:24:16;;13491:37;;13576:14;;13569:22;13557:35;;13548:45;;;-1:-1:-1;13470:133:16;;13612:320;12371:1;12364:14;;;12408:4;12395:18;;13707:1;13721:165;13735:6;13732:1;13729:13;13721:165;;;13813:14;;13800:11;;;13793:35;13856:16;;;;13750:10;;13721:165;;;13725:3;;13915:6;13910:3;13906:16;13899:23;;13436:496;;;;;;;13954:30;13980:3;13972:6;13954:30;:::i;:::-;-1:-1:-1;;;12672:20:16;;14051:1;14040:13;;;-1:-1:-1;;;;;12699:1360:16:o;14546:209::-;14578:1;14604;14594:132;;14648:10;14643:3;14639:20;14636:1;14629:31;14683:4;14680:1;14673:15;14711:4;14708:1;14701:15;14594:132;-1:-1:-1;14740:9:16;;14546:209::o;14760:127::-;14821:10;14816:3;14812:20;14809:1;14802:31;14852:4;14849:1;14842:15;14876:4;14873:1;14866:15;14892:171;14960:6;14999:10;;;14987;;;14983:27;;15022:12;;;15019:38;;;15037:18;;:::i;:::-;15019:38;14892:171;;;;:::o;15068:500::-;-1:-1:-1;;;;;15337:15:16;;;15319:34;;15389:15;;15384:2;15369:18;;15362:43;15436:2;15421:18;;15414:34;;;15484:3;15479:2;15464:18;;15457:31;;;15262:4;;15505:57;;15542:19;;15534:6;15505:57;:::i;:::-;15497:65;15068:500;-1:-1:-1;;;;;;15068:500:16:o;15573:249::-;15642:6;15695:2;15683:9;15674:7;15670:23;15666:32;15663:52;;;15711:1;15708;15701:12;15663:52;15743:9;15737:16;15762:30;15786:5;15762:30;:::i","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212207ac5a6e6be506a85fae21e7fe9bac8dc28def292429f10fcdae08401e7b6250964736f6c63430008180033","offset":9355}},"immutableReferences":{"7403":[{"start":2128,"length":32},{"start":3019,"length":32},{"start":3782,"length":32},{"start":5332,"length":32}],"7406":[{"start":1514,"length":32},{"start":2761,"length":32}],"7408":[{"start":1363,"length":32},{"start":4628,"length":32}],"7410":[{"start":986,"length":32}],"7412":[{"start":2210,"length":32},{"start":2906,"length":32},{"start":3669,"length":32},{"start":5442,"length":32}]},"transformations":[{"id":"7410","type":"replace","offset":986,"reason":"immutable"},{"id":"7408","type":"replace","offset":1363,"reason":"immutable"},{"id":"7406","type":"replace","offset":1514,"reason":"immutable"},{"id":"7403","type":"replace","offset":2128,"reason":"immutable"},{"id":"7412","type":"replace","offset":2210,"reason":"immutable"},{"id":"7406","type":"replace","offset":2761,"reason":"immutable"},{"id":"7412","type":"replace","offset":2906,"reason":"immutable"},{"id":"7403","type":"replace","offset":3019,"reason":"immutable"},{"id":"7412","type":"replace","offset":3669,"reason":"immutable"},{"id":"7403","type":"replace","offset":3782,"reason":"immutable"},{"id":"7408","type":"replace","offset":4628,"reason":"immutable"},{"id":"7403","type":"replace","offset":5332,"reason":"immutable"},{"id":"7412","type":"replace","offset":5442,"reason":"immutable"}],"transformationValues":{"immutables":{"7403":"0x00000000000000000000000060b9262456de011f7d15a54cdd8c48baaa8b022f","7406":"0x00000000000000000000000057cc350b844484eac0de444526d295c90f9ccbb5","7408":"0x00000000000000000000000045e2c8a09022914ce00cfce9a93dd3fda54d8686","7410":"0x000000000000000000000000000000000000000000000000000000006af0f7de","7412":"0x000000000000000000000000000000000000000000000000000000006af78f5e"}}},"deployment":{"transactionHash":"0x75c82b13b404a2228bfaff0a39f2da0da9e186d0f399cccd52574d8f50abbfa1","blockNumber":"132472780","transactionIndex":"34","deployer":"0x45E2c8a09022914cE00cFce9A93dD3FDa54D8686"},"sources":{"BahuangS3.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport \"@openzeppelin/contracts/token/ERC721/ERC721.sol\";\nimport \"@openzeppelin/contracts/utils/Strings.sol\";\n\ninterface IBalanceOf {\n    function balanceOf(address owner) external view returns (uint256);\n}\n\n/// 《山海经·八荒异兽·叁》 BAHUANG3\n/// 学 Agent Nakamigos（Agent ID 圈付费收入第一）的第二期打法：\n///  - 只限持有币安 .ai Agent ID 的钱包（SPACE ID 注册表 balanceOf > 0）\n///  - 免费：freeMint()（或 mint()），value = 0，一次调用领完。普通钱包 2 张；持有《八荒异兽·贰》的钱包 5 张。全局 6,000 张\n///  - 付费：paidMint(qty)，固定 BNB 价：付费第 1–1,500 张每张 0.0005 BNB，之后 0.0009 BNB。每钱包最多 20 张，全局 3,000 张，多付退回\n///  - 积分：免费每张 1 分、付费每张 2 分，记在链上 points(wallet)，供下一季读取（就像本季读取「贰」的持有人）\n///  - 一个钱包付费满 10 张，加送 烛龙、应龙 两张史诗卡\n///  - 无 owner、无管理函数、无提现：收入每笔直接打给 payout；铸造窗口部署时写死\ncontract BahuangS3 is ERC721 {\n    using Strings for uint256;\n\n    uint256 public constant FREE_CAP = 6000;\n    uint256 public constant PAID_CAP = 3000;\n    uint256 public constant FREE_PER_WALLET = 2;\n    uint256 public constant FREE_PER_HOLDER = 5;\n    uint256 public constant PAID_PER_WALLET = 20;\n    uint256 public constant EPIC_AT = 10;\n    uint256 public constant TIER1_END = 1500;\n    uint256 public constant PRICE1 = 0.0005 ether;\n    uint256 public constant PRICE2 = 0.0009 ether;\n    uint8 public constant BEAST_TYPES = 8;\n    uint8 public constant EPIC_ZHULONG = 8;\n    uint8 public constant EPIC_YINGLONG = 9;\n    uint256 private constant EPIC_BASE = 100000; // 赠送史诗 100001 起\n\n    IBalanceOf public immutable agentId;\n    IBalanceOf public immutable season2;\n    address payable public immutable payout;\n    uint256 public immutable mintStart;\n    uint256 public immutable mintEnd;\n    string private baseURI;\n\n    uint256 public freeMinted;\n    uint256 public paidMinted;\n    uint256 public epicMinted;\n    uint256 public totalRevenueWei;\n    uint256 public totalPoints;\n    mapping(address => uint8) public freeCount;\n    mapping(address => uint8) public paidCount;\n    mapping(address => uint256) public points;\n    mapping(uint256 => uint8) private _kindPlus1;\n    uint16[8] public kindLeft = [1500, 1500, 1500, 1500, 1000, 1000, 500, 500];\n    uint256 private _poolLeft = 9000;\n    uint256 private _nextId;\n\n    event FreeMinted(address indexed wallet, uint256 qty, bool holder);\n    event PaidMinted(address indexed wallet, uint256 qty, uint256 costWei);\n    event EpicRewarded(address indexed wallet);\n\n    constructor(\n        address registry,\n        address season2_,\n        address payable payout_,\n        uint256 durationSeconds,\n        string memory baseURI_\n    ) ERC721(unicode\"山海经·八荒异兽·叁\", \"BAHUANG3\") {\n        agentId = IBalanceOf(registry);\n        season2 = IBalanceOf(season2_);\n        payout = payout_;\n        mintStart = block.timestamp;\n        mintEnd = block.timestamp + durationSeconds;\n        baseURI = baseURI_;\n    }\n\n    modifier mintOpen() {\n        require(block.timestamp < mintEnd, \"mint ended\");\n        require(agentId.balanceOf(msg.sender) > 0, \"need .ai Agent ID\");\n        _;\n    }\n\n    // ---------- 铸造 ----------\n\n    function freeMint() public mintOpen {\n        uint256 allow = freeAllowance(msg.sender);\n        uint256 left = allow > freeCount[msg.sender] ? allow - freeCount[msg.sender] : 0;\n        require(left > 0, \"free used\");\n        uint256 globalLeft = FREE_CAP - freeMinted;\n        require(globalLeft > 0, \"free sold out\");\n        if (left > globalLeft) left = globalLeft;\n        freeCount[msg.sender] += uint8(left);\n        freeMinted += left;\n        points[msg.sender] += left;\n        totalPoints += left;\n        for (uint256 i; i < left; ++i) _mintBeast(msg.sender);\n        emit FreeMinted(msg.sender, left, allow == FREE_PER_HOLDER);\n    }\n\n    /// 与 freeMint() 相同，方便只认 mint() 的机器人\n    function mint() external {\n        freeMint();\n    }\n\n    function paidMint(uint256 qty) external payable mintOpen {\n        require(qty > 0, \"qty 0\");\n        require(paidCount[msg.sender] + qty <= PAID_PER_WALLET, \"max 20 paid\");\n        require(paidMinted + qty <= PAID_CAP, \"paid sold out\");\n        uint256 cost = costWei(qty);\n        require(msg.value >= cost, \"underpaid\");\n\n        uint256 before = paidCount[msg.sender];\n        paidCount[msg.sender] += uint8(qty);\n        paidMinted += qty;\n        totalRevenueWei += cost;\n        points[msg.sender] += 2 * qty;\n        totalPoints += 2 * qty;\n        for (uint256 i; i < qty; ++i) _mintBeast(msg.sender);\n\n        if (before < EPIC_AT && before + qty >= EPIC_AT) {\n            _mintEpic(msg.sender, EPIC_ZHULONG);\n            _mintEpic(msg.sender, EPIC_YINGLONG);\n            emit EpicRewarded(msg.sender);\n        }\n        emit PaidMinted(msg.sender, qty, cost);\n\n        (bool ok, ) = payout.call{value: cost}(\"\");\n        require(ok, \"payout failed\");\n        uint256 refund = msg.value - cost;\n        if (refund > 0) {\n            (bool r, ) = payable(msg.sender).call{value: refund}(\"\");\n            require(r, \"refund failed\");\n        }\n    }\n\n    // ---------- 只读 ----------\n\n    function isSeason2Holder(address wallet) public view returns (bool) {\n        return season2.balanceOf(wallet) > 0;\n    }\n\n    function freeAllowance(address wallet) public view returns (uint256) {\n        return isSeason2Holder(wallet) ? FREE_PER_HOLDER : FREE_PER_WALLET;\n    }\n\n    /// 第 n 张付费卡（从 1 起）的价格\n    function priceAt(uint256 n) public pure returns (uint256) {\n        return n <= TIER1_END ? PRICE1 : PRICE2;\n    }\n\n    /// 接下来 qty 张付费卡的总价（跨档自动分档计算）\n    function costWei(uint256 qty) public view returns (uint256 cost) {\n        for (uint256 i = 1; i <= qty; ++i) cost += priceAt(paidMinted + i);\n    }\n\n    function mintPriceWei() external view returns (uint256) {\n        return costWei(1);\n    }\n\n    function quote(address wallet, uint256 qty)\n        external\n        view\n        returns (uint256 freeLeft, uint256 paidLeft, uint256 cost, bool eligible, bool open, bool holder)\n    {\n        uint256 allow = freeAllowance(wallet);\n        uint256 fl = allow > freeCount[wallet] ? allow - freeCount[wallet] : 0;\n        uint256 fg = FREE_CAP - freeMinted;\n        freeLeft = fl < fg ? fl : fg;\n        uint256 pl = PAID_PER_WALLET - paidCount[wallet];\n        uint256 pg = PAID_CAP - paidMinted;\n        paidLeft = pl < pg ? pl : pg;\n        cost = costWei(qty);\n        eligible = agentId.balanceOf(wallet) > 0;\n        open = block.timestamp < mintEnd;\n        holder = allow == FREE_PER_HOLDER;\n    }\n\n    function totalMinted() external view returns (uint256) {\n        return freeMinted + paidMinted;\n    }\n\n    function tokenURI(uint256 id) public view override returns (string memory) {\n        return string.concat(baseURI, uint256(beastOf(id)).toString(), \".json\");\n    }\n\n    function beastOf(uint256 id) public view returns (uint8) {\n        _requireOwned(id);\n        return _kindPlus1[id] - 1;\n    }\n\n    // ---------- 内部 ----------\n\n    /// 按剩余配额加权抽种类，保证稀有度总数固定（随机数来自 prevrandao，出块者可影响）\n    function _mintBeast(address to) internal {\n        uint256 tokenId = ++_nextId;\n        uint256 pick = uint256(keccak256(abi.encode(block.prevrandao, to, tokenId))) % _poolLeft;\n        uint8 kind;\n        for (uint8 k; k < BEAST_TYPES; ++k) {\n            if (pick < kindLeft[k]) { kind = k; break; }\n            pick -= kindLeft[k];\n        }\n        kindLeft[kind] -= 1;\n        _poolLeft -= 1;\n        _kindPlus1[tokenId] = kind + 1;\n        _mint(to, tokenId);\n    }\n\n    function _mintEpic(address to, uint8 kind) internal {\n        uint256 tokenId = EPIC_BASE + (++epicMinted);\n        _kindPlus1[tokenId] = kind + 1;\n        _mint(to, tokenId);\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.24;\n\nimport {IERC721} from \"./IERC721.sol\";\nimport {IERC721Metadata} from \"./extensions/IERC721Metadata.sol\";\nimport {ERC721Utils} from \"./utils/ERC721Utils.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {Strings} from \"../../utils/Strings.sol\";\nimport {IERC165, ERC165} from \"../../utils/introspection/ERC165.sol\";\nimport {IERC721Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\nabstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {\n    using Strings for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    mapping(uint256 tokenId => address) private _owners;\n\n    mapping(address owner => uint256) private _balances;\n\n    mapping(uint256 tokenId => address) private _tokenApprovals;\n\n    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return\n            interfaceId == type(IERC721).interfaceId ||\n            interfaceId == type(IERC721Metadata).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /// @inheritdoc IERC721\n    function balanceOf(address owner) public view virtual returns (uint256) {\n        if (owner == address(0)) {\n            revert ERC721InvalidOwner(address(0));\n        }\n        return _balances[owner];\n    }\n\n    /// @inheritdoc IERC721\n    function ownerOf(uint256 tokenId) public view virtual returns (address) {\n        return _requireOwned(tokenId);\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {\n        _requireOwned(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /// @inheritdoc IERC721\n    function approve(address to, uint256 tokenId) public virtual {\n        _approve(to, tokenId, _msgSender());\n    }\n\n    /// @inheritdoc IERC721\n    function getApproved(uint256 tokenId) public view virtual returns (address) {\n        _requireOwned(tokenId);\n\n        return _getApproved(tokenId);\n    }\n\n    /// @inheritdoc IERC721\n    function setApprovalForAll(address operator, bool approved) public virtual {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /// @inheritdoc IERC721\n    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /// @inheritdoc IERC721\n    function transferFrom(address from, address to, uint256 tokenId) public virtual {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        // Setting an \"auth\" arguments enables the `_isAuthorized` check which verifies that the token exists\n        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.\n        address previousOwner = _update(to, tokenId, _msgSender());\n        if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /// @inheritdoc IERC721\n    function safeTransferFrom(address from, address to, uint256 tokenId) public {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /// @inheritdoc IERC721\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {\n        transferFrom(from, to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     *\n     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the\n     * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances\n     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by\n     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.\n     */\n    function _getApproved(uint256 tokenId) internal view virtual returns (address) {\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in\n     * particular (ignoring whether it is owned by `owner`).\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {\n        return\n            spender != address(0) &&\n            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.\n     * Reverts if:\n     * - `spender` does not have approval from `owner` for `tokenId`.\n     * - `spender` does not have approval to manage all of `owner`'s assets.\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {\n        if (!_isAuthorized(owner, spender, tokenId)) {\n            if (owner == address(0)) {\n                revert ERC721NonexistentToken(tokenId);\n            } else {\n                revert ERC721InsufficientApproval(spender, tokenId);\n            }\n        }\n    }\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that\n     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.\n     *\n     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the\n     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership\n     * remain consistent with one another.\n     */\n    function _increaseBalance(address account, uint128 value) internal virtual {\n        unchecked {\n            _balances[account] += value;\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner\n     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that\n     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.\n     */\n    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {\n        address from = _ownerOf(tokenId);\n\n        // Perform (optional) operator check\n        if (auth != address(0)) {\n            _checkAuthorized(from, auth, tokenId);\n        }\n\n        // Execute the update\n        if (from != address(0)) {\n            // Clear approval. No need to re-authorize or emit the Approval event\n            _approve(address(0), tokenId, address(0), false);\n\n            unchecked {\n                _balances[from] -= 1;\n            }\n        }\n\n        if (to != address(0)) {\n            unchecked {\n                _balances[to] += 1;\n            }\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        return from;\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner != address(0)) {\n            revert ERC721InvalidSender(address(0));\n        }\n    }\n\n    /**\n     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal {\n        address previousOwner = _update(address(0), tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        } else if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients\n     * are aware of the ERC-721 standard to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is like {safeTransferFrom} in the sense that it invokes\n     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `tokenId` token must exist and be owned by `from`.\n     * - `to` cannot be the zero address.\n     * - `from` cannot be the zero address.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId) internal {\n        _safeTransfer(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is\n     * either the owner of the token, or approved to operate on all tokens held by this owner.\n     *\n     * Emits an {Approval} event.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address to, uint256 tokenId, address auth) internal {\n        _approve(to, tokenId, auth, true);\n    }\n\n    /**\n     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not\n     * emitted in the context of transfers.\n     */\n    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {\n        // Avoid reading the owner unless necessary\n        if (emitEvent || auth != address(0)) {\n            address owner = _requireOwned(tokenId);\n\n            // We do not use _isAuthorized because single-token approvals should not be able to call approve\n            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {\n                revert ERC721InvalidApprover(auth);\n            }\n\n            if (emitEvent) {\n                emit Approval(owner, to, tokenId);\n            }\n        }\n\n        _tokenApprovals[tokenId] = to;\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Requirements:\n     * - operator can't be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        if (owner == address(0)) {\n            revert ERC721InvalidApprover(address(0));\n        }\n        if (operator == address(0)) {\n            revert ERC721InvalidOperator(operator);\n        }\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).\n     * Returns the owner.\n     *\n     * Overrides to ownership logic should be done to {_ownerOf}.\n     */\n    function _requireOwned(uint256 tokenId) internal view returns (address) {\n        address owner = _ownerOf(tokenId);\n        if (owner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n        return owner;\n    }\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/Strings.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SafeCast} from \"./math/SafeCast.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\nimport {Bytes} from \"./Bytes.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    using SafeCast for *;\n\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n    uint256 private constant SPECIAL_CHARS_LOOKUP =\n        0xffffffff | // first 32 bits corresponding to the control characters (U+0000 to U+001F)\n            (1 << 0x22) | // double quote\n            (1 << 0x5c); // backslash\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev The string being parsed contains characters that are not in scope of the given base.\n     */\n    error StringsInvalidChar();\n\n    /**\n     * @dev The string being parsed is not a properly formatted address.\n     */\n    error StringsInvalidAddressFormat();\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            assembly (\"memory-safe\") {\n                ptr := add(add(buffer, 0x20), length)\n            }\n            while (true) {\n                ptr--;\n                assembly (\"memory-safe\") {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `bytes` buffer to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(bytes memory input) internal pure returns (string memory) {\n        unchecked {\n            bytes memory buffer = new bytes(2 * input.length + 2);\n            buffer[0] = \"0\";\n            buffer[1] = \"x\";\n            for (uint256 i = 0; i < input.length; ++i) {\n                uint8 v = uint8(input[i]);\n                buffer[2 * i + 2] = HEX_DIGITS[v >> 4];\n                buffer[2 * i + 3] = HEX_DIGITS[v & 0xf];\n            }\n            return string(buffer);\n        }\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return Bytes.equal(bytes(a), bytes(b));\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input) internal pure returns (uint256) {\n        return parseUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        uint256 result = 0;\n        for (uint256 i = begin; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 9) return (false, 0);\n            result *= 10;\n            result += chr;\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `int256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input) internal pure returns (int256) {\n        return parseInt(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {\n        (bool success, int256 value) = tryParseInt(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if\n     * the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {\n        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    uint256 private constant ABS_MIN_INT256 = 2 ** 255;\n\n    /**\n     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character or if the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, int256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseIntUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseIntUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, int256 value) {\n        bytes memory buffer = bytes(input);\n\n        // Check presence of a negative sign.\n        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        bool positiveSign = sign == bytes1(\"+\");\n        bool negativeSign = sign == bytes1(\"-\");\n        uint256 offset = (positiveSign || negativeSign).toUint();\n\n        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);\n\n        if (absSuccess && absValue < ABS_MIN_INT256) {\n            return (true, negativeSign ? -int256(absValue) : int256(absValue));\n        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {\n            return (true, type(int256).min);\n        } else return (false, 0);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input) internal pure returns (uint256) {\n        return parseHexUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseHexUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an\n     * invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseHexUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseHexUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        // skip 0x prefix if present\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 offset = hasPrefix.toUint() * 2;\n\n        uint256 result = 0;\n        for (uint256 i = begin + offset; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 15) return (false, 0);\n            result *= 16;\n            unchecked {\n                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).\n                // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.\n                result += chr;\n            }\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as an `address`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input) internal pure returns (address) {\n        return parseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {\n        (bool success, address value) = tryParseAddress(input, begin, end);\n        if (!success) revert StringsInvalidAddressFormat();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly\n     * formatted address. See {parseAddress-string} requirements.\n     */\n    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {\n        return tryParseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly\n     * formatted address. See {parseAddress-string-uint256-uint256} requirements.\n     */\n    function tryParseAddress(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, address value) {\n        if (end > bytes(input).length || begin > end) return (false, address(0));\n\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;\n\n        // check that input is the correct length\n        if (end - begin == expectedLength) {\n            // length guarantees that this does not overflow, and value is at most type(uint160).max\n            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);\n            return (s, address(uint160(v)));\n        } else {\n            return (false, address(0));\n        }\n    }\n\n    function _tryParseChr(bytes1 chr) private pure returns (uint8) {\n        uint8 value = uint8(chr);\n\n        // Try to parse `chr`:\n        // - Case 1: [0-9]\n        // - Case 2: [a-f]\n        // - Case 3: [A-F]\n        // - otherwise not supported\n        unchecked {\n            if (value > 47 && value < 58) value -= 48;\n            else if (value > 96 && value < 103) value -= 87;\n            else if (value > 64 && value < 71) value -= 55;\n            else return type(uint8).max;\n        }\n\n        return value;\n    }\n\n    /**\n     * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.\n     *\n     * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.\n     *\n     * NOTE: This function escapes backslashes (including those in \\uXXXX sequences) and the characters in ranges\n     * defined in section 2.5 of RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). All control characters in U+0000\n     * to U+001F are escaped (\\b, \\t, \\n, \\f, \\r use short form; others use \\u00XX). ECMAScript's `JSON.parse` does\n     * recover escaped unicode characters that are not in this range, but other tooling may provide different results.\n     */\n    function escapeJSON(string memory input) internal pure returns (string memory) {\n        bytes memory buffer = bytes(input);\n\n        // Put output at the FMP. Memory will be reserved later when we figure out the actual length of the escaped\n        // string. All write are done using _unsafeWriteBytesOffset, which avoid the (expensive) length checks for\n        // each character written.\n        bytes memory output;\n        assembly (\"memory-safe\") {\n            output := mload(0x40)\n        }\n        uint256 outputLength = 0;\n\n        for (uint256 i = 0; i < buffer.length; ++i) {\n            uint8 char = uint8(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (((SPECIAL_CHARS_LOOKUP & (1 << char)) != 0)) {\n                _unsafeWriteBytesOffset(output, outputLength++, \"\\\\\");\n                if (char == 0x08) _unsafeWriteBytesOffset(output, outputLength++, \"b\");\n                else if (char == 0x09) _unsafeWriteBytesOffset(output, outputLength++, \"t\");\n                else if (char == 0x0a) _unsafeWriteBytesOffset(output, outputLength++, \"n\");\n                else if (char == 0x0c) _unsafeWriteBytesOffset(output, outputLength++, \"f\");\n                else if (char == 0x0d) _unsafeWriteBytesOffset(output, outputLength++, \"r\");\n                else if (char == 0x5c) _unsafeWriteBytesOffset(output, outputLength++, \"\\\\\");\n                else if (char == 0x22) {\n                    // solhint-disable-next-line quotes\n                    _unsafeWriteBytesOffset(output, outputLength++, '\"');\n                } else {\n                    // U+0000 to U+001F without short form: output \\u00XX\n                    _unsafeWriteBytesOffset(output, outputLength++, \"u\");\n                    _unsafeWriteBytesOffset(output, outputLength++, \"0\");\n                    _unsafeWriteBytesOffset(output, outputLength++, \"0\");\n                    _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char >> 4]);\n                    _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char & 0x0f]);\n                }\n            } else {\n                _unsafeWriteBytesOffset(output, outputLength++, bytes1(char));\n            }\n        }\n        // write the actual length and reserve memory\n        assembly (\"memory-safe\") {\n            mstore(output, outputLength)\n            mstore(0x40, add(output, add(outputLength, 0x20)))\n        }\n\n        return string(output);\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n\n    /**\n     * @dev Write a bytes1 to a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeWriteBytesOffset(bytes memory buffer, uint256 offset, bytes1 value) private pure {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            mstore8(add(add(buffer, 0x20), offset), shr(248, value))\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC-721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n     *   {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC721} from \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC721/utils/ERC721Utils.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721Receiver} from \"../IERC721Receiver.sol\";\nimport {IERC721Errors} from \"../../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Library that provides common ERC-721 utility functions.\n *\n * See https://eips.ethereum.org/EIPS/eip-721[ERC-721].\n *\n * _Available since v5.1._\n */\nlibrary ERC721Utils {\n    /**\n     * @dev Performs an acceptance check for the provided `operator` by calling {IERC721Receiver-onERC721Received}\n     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).\n     *\n     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).\n     * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept\n     * the transfer.\n     */\n    function checkOnERC721Received(\n        address operator,\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes memory data\n    ) internal {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) {\n                if (retval != IERC721Receiver.onERC721Received.selector) {\n                    // Token rejected\n                    revert IERC721Errors.ERC721InvalidReceiver(to);\n                }\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    // non-IERC721Receiver implementer\n                    revert IERC721Errors.ERC721InvalidReceiver(to);\n                } else {\n                    assembly (\"memory-safe\") {\n                        revert(add(reason, 0x20), mload(reason))\n                    }\n                }\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)\n\npragma solidity >=0.8.4;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Return the 512-bit addition of two uint256.\n     *\n     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.\n     */\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        assembly (\"memory-safe\") {\n            low := add(a, b)\n            high := lt(low, a)\n        }\n    }\n\n    /**\n     * @dev Return the 512-bit multiplication of two uint256.\n     *\n     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.\n     */\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n        // variables such that product = high * 2²⁵⁶ + low.\n        assembly (\"memory-safe\") {\n            let mm := mulmod(a, b, not(0))\n            low := mul(a, b)\n            high := sub(sub(mm, low), lt(mm, low))\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            success = c >= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a - b;\n            success = c <= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a * b;\n            assembly (\"memory-safe\") {\n                // Only true when the multiplication doesn't overflow\n                // (c / a == b) || (a == 0)\n                success := or(eq(div(c, a), b), iszero(a))\n            }\n            // equivalent to: success ? c : 0\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `DIV` opcode returns zero when the denominator is 0.\n                result := div(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `MOD` opcode returns zero when the denominator is 0.\n                result := mod(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryAdd(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\n     */\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\n        (, uint256 result) = trySub(a, b);\n        return result;\n    }\n\n    /**\n     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryMul(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // (a + b) / 2 can overflow.\n            return (a & b) + (a ^ b) / 2;\n        }\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (high == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return low / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= high) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [high low].\n            uint256 remainder;\n            assembly (\"memory-safe\") {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                high := sub(high, gt(remainder, low))\n                low := sub(low, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly (\"memory-safe\") {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [high low] by twos.\n                low := div(low, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from high into low.\n            low |= high * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high\n            // is no longer required.\n            result = low * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n            if (high >= 1 << n) {\n                Panic.panic(Panic.UNDER_OVERFLOW);\n            }\n            return (high << (256 - n)) | (low >> n);\n        }\n    }\n\n    /**\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory buffer) private pure returns (bool) {\n        uint256 chunk;\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            // See _unsafeReadBytesOffset from utils/Bytes.sol\n            assembly (\"memory-safe\") {\n                chunk := mload(add(add(buffer, 0x20), i))\n            }\n            if (chunk >> (8 * saturatingSub(i + 0x20, buffer.length)) != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // If upper 8 bits of 16-bit half set, add 8 to result\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\n        // If upper 4 bits of 8-bit half set, add 4 to result\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\n\n        // Shifts value right by the current result and use it as an index into this lookup table:\n        //\n        // | x (4 bits) |  index  | table[index] = MSB position |\n        // |------------|---------|-----------------------------|\n        // |    0000    |    0    |        table[0] = 0         |\n        // |    0001    |    1    |        table[1] = 0         |\n        // |    0010    |    2    |        table[2] = 1         |\n        // |    0011    |    3    |        table[3] = 1         |\n        // |    0100    |    4    |        table[4] = 2         |\n        // |    0101    |    5    |        table[5] = 2         |\n        // |    0110    |    6    |        table[6] = 2         |\n        // |    0111    |    7    |        table[7] = 2         |\n        // |    1000    |    8    |        table[8] = 3         |\n        // |    1001    |    9    |        table[9] = 3         |\n        // |    1010    |   10    |        table[10] = 3        |\n        // |    1011    |   11    |        table[11] = 3        |\n        // |    1100    |   12    |        table[12] = 3        |\n        // |    1101    |   13    |        table[13] = 3        |\n        // |    1110    |   14    |        table[14] = 3        |\n        // |    1111    |   15    |        table[15] = 3        |\n        //\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the first 16 bytes (most significant half).\n        assembly (\"memory-safe\") {\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits in a uint256.\n     */\n    function clz(uint256 x) internal pure returns (uint256) {\n        return ternary(x == 0, 256, 255 - log2(x));\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in a uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in a uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev A uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        assembly (\"memory-safe\") {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Bytes.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/Bytes.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\n\n/**\n * @dev Bytes operations.\n */\nlibrary Bytes {\n    /**\n     * @dev Forward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the first instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return indexOf(buffer, s, 0);\n    }\n\n    /**\n     * @dev Forward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or after `pos`), returns the index of the next instance\n     * * If `s` is not present in the buffer (at or after `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        uint256 length = buffer.length;\n        for (uint256 i = pos; i < length; ++i) {\n            if (bytes1(_unsafeReadBytesOffset(buffer, i)) == s) {\n                return i;\n            }\n        }\n        return type(uint256).max;\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the last instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return lastIndexOf(buffer, s, type(uint256).max);\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or before `pos`), returns the index of the previous instance\n     * * If `s` is not present in the buffer (at or before `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        unchecked {\n            uint256 length = buffer.length;\n            for (uint256 i = Math.min(Math.saturatingAdd(pos, 1), length); i > 0; --i) {\n                if (bytes1(_unsafeReadBytesOffset(buffer, i - 1)) == s) {\n                    return i - 1;\n                }\n            }\n            return type(uint256).max;\n        }\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to the end of `buffer` into a new bytes object in\n     * memory.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return slice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to `end` (excluded) into a new bytes object in\n     * memory. The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // allocate and copy\n        bytes memory result = new bytes(end - start);\n        assembly (\"memory-safe\") {\n            mcopy(add(result, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to the end of `buffer` to the start of that buffer,\n     * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:].\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     */\n    function splice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return splice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to `end` (excluded) to the start of that buffer,\n     * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:end].\n     * The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     */\n    function splice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // move and resize\n        assembly (\"memory-safe\") {\n            mcopy(add(buffer, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n            mstore(buffer, sub(end, start))\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Replaces bytes in `buffer` starting at `pos` with all bytes from `replacement`.\n     *\n     * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`).\n     * If `pos >= buffer.length`, no replacement occurs and the buffer is returned unchanged.\n     *\n     * NOTE: This function modifies the provided buffer in place.\n     */\n    function replace(bytes memory buffer, uint256 pos, bytes memory replacement) internal pure returns (bytes memory) {\n        return replace(buffer, pos, replacement, 0, replacement.length);\n    }\n\n    /**\n     * @dev Replaces bytes in `buffer` starting at `pos` with bytes from `replacement` starting at `offset`.\n     * Copies at most `length` bytes from `replacement` to `buffer`.\n     *\n     * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`, `offset` is\n     * clamped to `[0, replacement.length]`, and `length` is clamped to `min(length, replacement.length - offset,\n     * buffer.length - pos))`. If `pos >= buffer.length` or `offset >= replacement.length`, no replacement occurs\n     * and the buffer is returned unchanged.\n     *\n     * NOTE: This function modifies the provided buffer in place.\n     */\n    function replace(\n        bytes memory buffer,\n        uint256 pos,\n        bytes memory replacement,\n        uint256 offset,\n        uint256 length\n    ) internal pure returns (bytes memory) {\n        // sanitize\n        pos = Math.min(pos, buffer.length);\n        offset = Math.min(offset, replacement.length);\n        length = Math.min(length, Math.min(replacement.length - offset, buffer.length - pos));\n\n        // replace\n        assembly (\"memory-safe\") {\n            mcopy(add(add(buffer, 0x20), pos), add(add(replacement, 0x20), offset), length)\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Concatenate an array of bytes into a single bytes object.\n     *\n     * For fixed bytes types, we recommend using the solidity built-in `bytes.concat` or (equivalent)\n     * `abi.encodePacked`.\n     *\n     * NOTE: this could be done in assembly with a single loop that expands starting at the FMP, but that would be\n     * significantly less readable. It might be worth benchmarking the savings of the full-assembly approach.\n     */\n    function concat(bytes[] memory buffers) internal pure returns (bytes memory) {\n        uint256 length = 0;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            length += buffers[i].length;\n        }\n\n        bytes memory result = new bytes(length);\n\n        uint256 offset = 0x20;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            bytes memory input = buffers[i];\n            assembly (\"memory-safe\") {\n                mcopy(add(result, offset), add(input, 0x20), mload(input))\n            }\n            unchecked {\n                offset += input.length;\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Split each byte in `input` into two nibbles (4 bits each)\n     *\n     * Example: hex\"01234567\" → hex\"0001020304050607\"\n     */\n    function toNibbles(bytes memory input) internal pure returns (bytes memory output) {\n        assembly (\"memory-safe\") {\n            let length := mload(input)\n            output := mload(0x40)\n            mstore(0x40, add(add(output, 0x20), mul(length, 2)))\n            mstore(output, mul(length, 2))\n            for {\n                let i := 0\n            } lt(i, length) {\n                i := add(i, 0x10)\n            } {\n                let chunk := shr(128, mload(add(add(input, 0x20), i)))\n                chunk := and(\n                    0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff,\n                    or(shl(64, chunk), chunk)\n                )\n                chunk := and(\n                    0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff,\n                    or(shl(32, chunk), chunk)\n                )\n                chunk := and(\n                    0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff,\n                    or(shl(16, chunk), chunk)\n                )\n                chunk := and(\n                    0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff,\n                    or(shl(8, chunk), chunk)\n                )\n                chunk := and(\n                    0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f,\n                    or(shl(4, chunk), chunk)\n                )\n                mstore(add(add(output, 0x20), mul(i, 2)), chunk)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns true if the two byte buffers are equal.\n     */\n    function equal(bytes memory a, bytes memory b) internal pure returns (bool) {\n        return a.length == b.length && keccak256(a) == keccak256(b);\n    }\n\n    /**\n     * @dev Reverses the byte order of a bytes32 value, converting between little-endian and big-endian.\n     * Inspired by https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel[Reverse Parallel]\n     */\n    function reverseBytes32(bytes32 value) internal pure returns (bytes32) {\n        value = // swap bytes\n            ((value >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        value = // swap 8-byte long pairs\n            ((value >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |\n            ((value & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);\n        return (value >> 128) | (value << 128); // swap 16-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 128-bit values.\n    function reverseBytes16(bytes16 value) internal pure returns (bytes16) {\n        value = // swap bytes\n            ((value & 0xFF00FF00FF00FF00FF00FF00FF00FF00) >> 8) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value & 0xFFFF0000FFFF0000FFFF0000FFFF0000) >> 16) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value & 0xFFFFFFFF00000000FFFFFFFF00000000) >> 32) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        return (value >> 64) | (value << 64); // swap 8-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 64-bit values.\n    function reverseBytes8(bytes8 value) internal pure returns (bytes8) {\n        value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8); // swap bytes\n        value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16); // swap 2-byte long pairs\n        return (value >> 32) | (value << 32); // swap 4-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 32-bit values.\n    function reverseBytes4(bytes4 value) internal pure returns (bytes4) {\n        value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); // swap bytes\n        return (value >> 16) | (value << 16); // swap 2-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 16-bit values.\n    function reverseBytes2(bytes2 value) internal pure returns (bytes2) {\n        return (value >> 8) | (value << 8);\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits a bytes array. Returns `8 * buffer.length`\n     * if the buffer is all zeros.\n     */\n    function clz(bytes memory buffer) internal pure returns (uint256) {\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            bytes32 chunk = _unsafeReadBytesOffset(buffer, i);\n            if (chunk != bytes32(0)) {\n                return Math.min(8 * i + Math.clz(uint256(chunk)), 8 * buffer.length);\n            }\n        }\n        return 8 * buffer.length;\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @title ERC-721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC-721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n *\n * _Available since v5.1._\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.24+commit.e11b9ed9","compilerSettings":{"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun"},"name":"BahuangS3","fullyQualifiedName":"BahuangS3.sol:BahuangS3"},"abi":[{"type":"constructor","inputs":[{"name":"registry","type":"address","internalType":"address"},{"name":"season2_","type":"address","internalType":"address"},{"name":"payout_","type":"address","internalType":"address payable"},{"name":"durationSeconds","type":"uint256","internalType":"uint256"},{"name":"baseURI_","type":"string","internalType":"string"}],"stateMutability":"nonpayable"},{"name":"ERC721IncorrectOwner","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InsufficientApproval","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"ERC721InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOperator","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC721NonexistentToken","type":"error","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"ApprovalForAll","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"operator","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"EpicRewarded","type":"event","inputs":[{"name":"wallet","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"FreeMinted","type":"event","inputs":[{"name":"wallet","type":"address","indexed":true,"internalType":"address"},{"name":"qty","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"holder","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"PaidMinted","type":"event","inputs":[{"name":"wallet","type":"address","indexed":true,"internalType":"address"},{"name":"qty","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"costWei","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":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"BEAST_TYPES","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"EPIC_AT","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"EPIC_YINGLONG","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"EPIC_ZHULONG","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"FREE_CAP","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"FREE_PER_HOLDER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"FREE_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PAID_CAP","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PAID_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PRICE1","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PRICE2","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"TIER1_END","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"agentId","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IBalanceOf"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"beastOf","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"costWei","type":"function","inputs":[{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"cost","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"epicMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freeAllowance","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freeCount","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"freeMint","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"freeMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"isApprovedForAll","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isSeason2Holder","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"kindLeft","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint16","internalType":"uint16"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"mintEnd","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"mintPriceWei","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"mintStart","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":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"paidCount","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"paidMint","type":"function","inputs":[{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"paidMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"payout","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address payable"}],"stateMutability":"view"},{"name":"points","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"priceAt","type":"function","inputs":[{"name":"n","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"quote","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"freeLeft","type":"uint256","internalType":"uint256"},{"name":"paidLeft","type":"uint256","internalType":"uint256"},{"name":"cost","type":"uint256","internalType":"uint256"},{"name":"eligible","type":"bool","internalType":"bool"},{"name":"open","type":"bool","internalType":"bool"},{"name":"holder","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"season2","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IBalanceOf"}],"stateMutability":"view"},{"name":"setApprovalForAll","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"approved","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalPoints","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalRevenueWei","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.24+commit.e11b9ed9"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"registry","type":"address"},{"internalType":"address","name":"season2_","type":"address"},{"internalType":"address payable","name":"payout_","type":"address"},{"internalType":"uint256","name":"durationSeconds","type":"uint256"},{"internalType":"string","name":"baseURI_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"}],"name":"EpicRewarded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"qty","type":"uint256"},{"indexed":false,"internalType":"bool","name":"holder","type":"bool"}],"name":"FreeMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"qty","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"costWei","type":"uint256"}],"name":"PaidMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BEAST_TYPES","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EPIC_AT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EPIC_YINGLONG","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EPIC_ZHULONG","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FREE_CAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FREE_PER_HOLDER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FREE_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAID_CAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAID_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TIER1_END","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"agentId","outputs":[{"internalType":"contract IBalanceOf","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"beastOf","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"costWei","outputs":[{"internalType":"uint256","name":"cost","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epicMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"freeAllowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"freeCount","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"freeMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"isSeason2Holder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"kindLeft","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPriceWei","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintStart","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":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"paidCount","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"paidMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"paidMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"payout","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"points","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"n","type":"uint256"}],"name":"priceAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"quote","outputs":[{"internalType":"uint256","name":"freeLeft","type":"uint256"},{"internalType":"uint256","name":"paidLeft","type":"uint256"},{"internalType":"uint256","name":"cost","type":"uint256"},{"internalType":"bool","name":"eligible","type":"bool"},{"internalType":"bool","name":"open","type":"bool"},{"internalType":"bool","name":"holder","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"season2","outputs":[{"internalType":"contract IBalanceOf","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalPoints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRevenueWei","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"errors":{"ERC721IncorrectOwner(address,uint256,address)":[{"details":"Indicates an error related to the ownership over a particular token. Used in transfers.","params":{"owner":"Address of the current owner of a token.","sender":"Address whose tokens are being transferred.","tokenId":"Identifier number of a token."}}],"ERC721InsufficientApproval(address,uint256)":[{"details":"Indicates a failure with the `operator`’s approval. Used in transfers.","params":{"operator":"Address that may be allowed to operate on tokens without being their owner.","tokenId":"Identifier number of a token."}}],"ERC721InvalidApprover(address)":[{"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals.","params":{"approver":"Address initiating an approval operation."}}],"ERC721InvalidOperator(address)":[{"details":"Indicates a failure with the `operator` to be approved. Used in approvals.","params":{"operator":"Address that may be allowed to operate on tokens without being their owner."}}],"ERC721InvalidOwner(address)":[{"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. Used in balance queries.","params":{"owner":"Address of the current owner of a token."}}],"ERC721InvalidReceiver(address)":[{"details":"Indicates a failure with the token `receiver`. Used in transfers.","params":{"receiver":"Address to which tokens are being transferred."}}],"ERC721InvalidSender(address)":[{"details":"Indicates a failure with the token `sender`. Used in transfers.","params":{"sender":"Address whose tokens are being transferred."}}],"ERC721NonexistentToken(uint256)":[{"details":"Indicates a `tokenId` whose `owner` is the zero address.","params":{"tokenId":"Identifier number of a token."}}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."}},"kind":"dev","methods":{"approve(address,uint256)":{"details":"Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event."},"balanceOf(address)":{"details":"Returns the number of tokens in ``owner``'s account."},"getApproved(uint256)":{"details":"Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist."},"isApprovedForAll(address,address)":{"details":"Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}"},"name()":{"details":"Returns the token collection name."},"ownerOf(uint256)":{"details":"Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist."},"safeTransferFrom(address,address,uint256)":{"details":"Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or   {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."},"setApprovalForAll(address,bool)":{"details":"Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the address zero. Emits an {ApprovalForAll} event."},"supportsInterface(bytes4)":{"details":"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas."},"symbol()":{"details":"Returns the token collection symbol."},"transferFrom(address,address,uint256)":{"details":"Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event."}},"version":1},"userdoc":{"kind":"user","methods":{"costWei(uint256)":{"notice":"接下来 qty 张付费卡的总价（跨档自动分档计算）"},"mint()":{"notice":"与 freeMint() 相同，方便只认 mint() 的机器人"},"priceAt(uint256)":{"notice":"第 n 张付费卡（从 1 起）的价格"}},"notice":"《山海经·八荒异兽·叁》 BAHUANG3 学 Agent Nakamigos（Agent ID 圈付费收入第一）的第二期打法：  - 只限持有币安 .ai Agent ID 的钱包（SPACE ID 注册表 balanceOf > 0）  - 免费：freeMint()（或 mint()），value = 0，一次调用领完。普通钱包 2 张；持有《八荒异兽·贰》的钱包 5 张。全局 6,000 张  - 付费：paidMint(qty)，固定 BNB 价：付费第 1–1,500 张每张 0.0005 BNB，之后 0.0009 BNB。每钱包最多 20 张，全局 3,000 张，多付退回  - 积分：免费每张 1 分、付费每张 2 分，记在链上 points(wallet)，供下一季读取（就像本季读取「贰」的持有人）  - 一个钱包付费满 10 张，加送 烛龙、应龙 两张史诗卡  - 无 owner、无管理函数、无提现：收入每笔直接打给 payout；铸造窗口部署时写死","version":1}},"settings":{"compilationTarget":{"BahuangS3.sol":"BahuangS3"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"keccak256":"0x1b88b3fb3d85ba5496d7d5f396f83ee1fddcdd6762059ff65992655b67920998","license":"MIT","urls":["bzz-raw://89393bb3212da1c0889601b9706a07b39419ddc4d2faab9eaf6e7f9152cf6a1c","dweb:/ipfs/QmcCfzzxv1Bkdz1c1yF4gQCeYb6Us5BJANnzTFqawfd1HL"]},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"keccak256":"0xf6bb0dc431a9c50e25756412ec14cfcd4dc61dd40b8dc0e1b58ec09fce6d5564","license":"MIT","urls":["bzz-raw://eb87fef7e8ed754b8600cd5d42e4f23128059006368ffd19e4d50cc166471ee5","dweb:/ipfs/Qmc1vy1cevKreGUsG7S79gyhNvDtPnNz9qG47eYVHmMKLs"]},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"keccak256":"0xf78f05f3b8c9f75570e85300d7b4600d7f6f6a198449273f31d44c1641adb46f","license":"MIT","urls":["bzz-raw://e28b872613b45e0e801d4995aa4380be2531147bfe2d85c1d6275f1de514fba3","dweb:/ipfs/QmeeFcfShHYaS3BdgVj78nxR28ZaVUwbvr66ud8bT6kzw9"]},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"keccak256":"0x88cd5e3bee2e8c36b8d9058fbcaa81ad5704281b25634122234b55ea853d8055","license":"MIT","urls":["bzz-raw://8dc7e7ab5b8ea36c15027ab04221b05d1c970f47a53e9fd47ead8ca665d49c7e","dweb:/ipfs/Qmeeph7fsDyfRr8vb2L8KcDEmKPb224TAayMvgqgGAnqpL"]},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"keccak256":"0xf46268c37522320bb2119a5a394bc5c739a95c0c574c8d08e8c643f4d06e5c76","license":"MIT","urls":["bzz-raw://517e4b295f35b9947c72ad7379a6089439ece7bb6f4a2ea0a159da13046c039e","dweb:/ipfs/QmZXzkSfLUbvujig3zVbpDHykpHhqLpvQtdiN3B5j4TA3u"]},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"keccak256":"0xc7efbc23214ad7dced8bf2249460f4bda114d57f6a0079f84040654280f455bd","license":"MIT","urls":["bzz-raw://1f5bd44efca8c8c0d74439e7b808d1f9c4af1df78f91fef8e8bbca8104645435","dweb:/ipfs/Qmb42XSd8MKsEitp42sZkSFGqDRigk6QgGXtiJyJqUZJJ6"]},"@openzeppelin/contracts/utils/Bytes.sol":{"keccak256":"0xf80e4b96b6849936ea0fabd76cf81b13d7276295fddb1e1c07afb3ddf650b0ac","license":"MIT","urls":["bzz-raw://6430007255ac11c6e9c4331a418f3af52ff66fbbae959f645301d025b20aeb08","dweb:/ipfs/QmQE5fjmBBRw9ndnzJuC2uskYss1gbaR7JdazoCf1FGoBj"]},"@openzeppelin/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"@openzeppelin/contracts/utils/Panic.sol":{"keccak256":"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a","license":"MIT","urls":["bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a","dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG"]},"@openzeppelin/contracts/utils/Strings.sol":{"keccak256":"0x1fdc2de9585ab0f1c417f02a873a2b6343cd64bb7ffec6b00ffa11a4a158d9e8","license":"MIT","urls":["bzz-raw://1ab223a3d969c6cd7610049431dd42740960c477e45878f5d8b54411f7a32bdc","dweb:/ipfs/QmWumhjvhpKcwx3vDPQninsNVTc3BGvqaihkQakFkQYpaS"]},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"keccak256":"0x2d9dc2fe26180f74c11c13663647d38e259e45f95eb88f57b61d2160b0109d3e","license":"MIT","urls":["bzz-raw://81233d1f98060113d9922180bb0f14f8335856fe9f339134b09335e9f678c377","dweb:/ipfs/QmWh6R35SarhAn4z2wH8SU456jJSYL2FgucfTFgbHJJN4E"]},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c","license":"MIT","urls":["bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617","dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u"]},"@openzeppelin/contracts/utils/math/Math.sol":{"keccak256":"0x59973a93b1f983f94e10529f46ca46544a9fec2b5f56fb1390bbe9e0dc79f857","license":"MIT","urls":["bzz-raw://c55ef8f0b9719790c2ae6f81d80a59ffb89f2f0abe6bc065585bd79edce058c5","dweb:/ipfs/QmNNmCbX9NjPXKqHJN8R1WC2rNeZSQrPZLd6FF6AKLyH5Y"]},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"keccak256":"0xc8cae21c9ae4a46e5162ff9bf5b351d6fa6a6eba72d515f3bc1bdfeda7fdf083","license":"MIT","urls":["bzz-raw://ce830ebcf28e31643caba318996db3763c36d52cd0f23798ba83c135355d45e9","dweb:/ipfs/QmdGPcvptHN7UBCbUYBbRX3hiRVRFLRwno8b4uga6uFNif"]},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"keccak256":"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3","license":"MIT","urls":["bzz-raw://db5fbb3dddd8b7047465b62575d96231ba8a2774d37fb4737fbf23340fabbb03","dweb:/ipfs/QmVUSvooZKEdEdap619tcJjTLcAuH6QBdZqAzWwnAXZAWJ"]},"BahuangS3.sol":{"keccak256":"0xbbe2af98a85e3ac4d97bef3ed4bd181a814172fce9b7d96d0e46d1aca75d3cc0","license":"MIT","urls":["bzz-raw://2025ec07e45ce50bbfb5f16c1e69884ad35a483784840492acb46a1e66a14079","dweb:/ipfs/QmPVX1Y7BQu93Tk8VnJDAwEJM1ja8urBo9pNtad8gyD1UW"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint8":{"label":"uint8","encoding":"inplace","numberOfBytes":"1"},"t_uint16":{"label":"uint16","encoding":"inplace","numberOfBytes":"2"},"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_array(t_uint16)8_storage":{"base":"t_uint16","label":"uint16[8]","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint8)":{"key":"t_address","label":"mapping(address => uint8)","value":"t_uint8","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_uint8)":{"key":"t_uint256","label":"mapping(uint256 => uint8)","value":"t_uint8","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_address)":{"key":"t_uint256","label":"mapping(uint256 => address)","value":"t_address","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_bool))":{"key":"t_address","label":"mapping(address => mapping(address => bool))","value":"t_mapping(t_address,t_bool)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_string_storage","astId":169,"label":"_name","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"1","type":"t_string_storage","astId":171,"label":"_symbol","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"2","type":"t_mapping(t_uint256,t_address)","astId":175,"label":"_owners","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"3","type":"t_mapping(t_address,t_uint256)","astId":179,"label":"_balances","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"4","type":"t_mapping(t_uint256,t_address)","astId":183,"label":"_tokenApprovals","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"5","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":189,"label":"_operatorApprovals","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"6","type":"t_string_storage","astId":7414,"label":"baseURI","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"7","type":"t_uint256","astId":7416,"label":"freeMinted","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"8","type":"t_uint256","astId":7418,"label":"paidMinted","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"9","type":"t_uint256","astId":7420,"label":"epicMinted","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"10","type":"t_uint256","astId":7422,"label":"totalRevenueWei","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"11","type":"t_uint256","astId":7424,"label":"totalPoints","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"12","type":"t_mapping(t_address,t_uint8)","astId":7428,"label":"freeCount","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"13","type":"t_mapping(t_address,t_uint8)","astId":7432,"label":"paidCount","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"14","type":"t_mapping(t_address,t_uint256)","astId":7436,"label":"points","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"15","type":"t_mapping(t_uint256,t_uint8)","astId":7440,"label":"_kindPlus1","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"16","type":"t_array(t_uint16)8_storage","astId":7453,"label":"kindLeft","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"17","type":"t_uint256","astId":7456,"label":"_poolLeft","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"18","type":"t_uint256","astId":7458,"label":"_nextId","offset":0,"contract":"BahuangS3.sol:BahuangS3"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"《山海经·八荒异兽·叁》 BAHUANG3 学 Agent Nakamigos（Agent ID 圈付费收入第一）的第二期打法：  - 只限持有币安 .ai Agent ID 的钱包（SPACE ID 注册表 balanceOf > 0）  - 免费：freeMint()（或 mint()），value = 0，一次调用领完。普通钱包 2 张；持有《八荒异兽·贰》的钱包 5 张。全局 6,000 张  - 付费：paidMint(qty)，固定 BNB 价：付费第 1–1,500 张每张 0.0005 BNB，之后 0.0009 BNB。每钱包最多 20 张，全局 3,000 张，多付退回  - 积分：免费每张 1 分、付费每张 2 分，记在链上 points(wallet)，供下一季读取（就像本季读取「贰」的持有人）  - 一个钱包付费满 10 张，加送 烛龙、应龙 两张史诗卡  - 无 owner、无管理函数、无提现：收入每笔直接打给 payout；铸造窗口部署时写死","methods":{"mint()":{"notice":"与 freeMint() 相同，方便只认 mint() 的机器人"},"costWei(uint256)":{"notice":"接下来 qty 张付费卡的总价（跨档自动分档计算）"},"priceAt(uint256)":{"notice":"第 n 张付费卡（从 1 起）的价格"}},"version":1},"devdoc":{"kind":"dev","errors":{"ERC721InvalidOwner(address)":[{"params":{"owner":"Address of the current owner of a token."},"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. Used in balance queries."}],"ERC721InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC721InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC721InvalidOperator(address)":[{"params":{"operator":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `operator` to be approved. Used in approvals."}],"ERC721InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"ERC721NonexistentToken(uint256)":[{"params":{"tokenId":"Identifier number of a token."},"details":"Indicates a `tokenId` whose `owner` is the zero address."}],"ERC721InsufficientApproval(address,uint256)":[{"params":{"tokenId":"Identifier number of a token.","operator":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `operator`’s approval. Used in transfers."}],"ERC721IncorrectOwner(address,uint256,address)":[{"params":{"owner":"Address of the current owner of a token.","sender":"Address whose tokens are being transferred.","tokenId":"Identifier number of a token."},"details":"Indicates an error related to the ownership over a particular token. Used in transfers."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."}},"methods":{"name()":{"details":"Returns the token collection name."},"symbol()":{"details":"Returns the token collection symbol."},"ownerOf(uint256)":{"details":"Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist."},"balanceOf(address)":{"details":"Returns the number of tokens in ``owner``'s account."},"getApproved(uint256)":{"details":"Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist."},"approve(address,uint256)":{"details":"Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event."},"supportsInterface(bytes4)":{"details":"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas."},"setApprovalForAll(address,bool)":{"details":"Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the address zero. Emits an {ApprovalForAll} event."},"isApprovedForAll(address,address)":{"details":"Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}"},"transferFrom(address,address,uint256)":{"details":"Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256)":{"details":"Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or   {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."}},"version":1},"sourceIds":{"BahuangS3.sol":{"id":15},"@openzeppelin/contracts/utils/Bytes.sol":{"id":6},"@openzeppelin/contracts/utils/Panic.sol":{"id":8},"@openzeppelin/contracts/utils/Context.sol":{"id":7},"@openzeppelin/contracts/utils/Strings.sol":{"id":9},"@openzeppelin/contracts/utils/math/Math.sol":{"id":12},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"id":1},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"id":13},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"id":2},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"id":14},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":0},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":10},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":11},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"id":3},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"id":5},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"id":4}},"additionalInput":null,"stdJsonInput":{"sources":{"BahuangS3.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport \"@openzeppelin/contracts/token/ERC721/ERC721.sol\";\nimport \"@openzeppelin/contracts/utils/Strings.sol\";\n\ninterface IBalanceOf {\n    function balanceOf(address owner) external view returns (uint256);\n}\n\n/// 《山海经·八荒异兽·叁》 BAHUANG3\n/// 学 Agent Nakamigos（Agent ID 圈付费收入第一）的第二期打法：\n///  - 只限持有币安 .ai Agent ID 的钱包（SPACE ID 注册表 balanceOf > 0）\n///  - 免费：freeMint()（或 mint()），value = 0，一次调用领完。普通钱包 2 张；持有《八荒异兽·贰》的钱包 5 张。全局 6,000 张\n///  - 付费：paidMint(qty)，固定 BNB 价：付费第 1–1,500 张每张 0.0005 BNB，之后 0.0009 BNB。每钱包最多 20 张，全局 3,000 张，多付退回\n///  - 积分：免费每张 1 分、付费每张 2 分，记在链上 points(wallet)，供下一季读取（就像本季读取「贰」的持有人）\n///  - 一个钱包付费满 10 张，加送 烛龙、应龙 两张史诗卡\n///  - 无 owner、无管理函数、无提现：收入每笔直接打给 payout；铸造窗口部署时写死\ncontract BahuangS3 is ERC721 {\n    using Strings for uint256;\n\n    uint256 public constant FREE_CAP = 6000;\n    uint256 public constant PAID_CAP = 3000;\n    uint256 public constant FREE_PER_WALLET = 2;\n    uint256 public constant FREE_PER_HOLDER = 5;\n    uint256 public constant PAID_PER_WALLET = 20;\n    uint256 public constant EPIC_AT = 10;\n    uint256 public constant TIER1_END = 1500;\n    uint256 public constant PRICE1 = 0.0005 ether;\n    uint256 public constant PRICE2 = 0.0009 ether;\n    uint8 public constant BEAST_TYPES = 8;\n    uint8 public constant EPIC_ZHULONG = 8;\n    uint8 public constant EPIC_YINGLONG = 9;\n    uint256 private constant EPIC_BASE = 100000; // 赠送史诗 100001 起\n\n    IBalanceOf public immutable agentId;\n    IBalanceOf public immutable season2;\n    address payable public immutable payout;\n    uint256 public immutable mintStart;\n    uint256 public immutable mintEnd;\n    string private baseURI;\n\n    uint256 public freeMinted;\n    uint256 public paidMinted;\n    uint256 public epicMinted;\n    uint256 public totalRevenueWei;\n    uint256 public totalPoints;\n    mapping(address => uint8) public freeCount;\n    mapping(address => uint8) public paidCount;\n    mapping(address => uint256) public points;\n    mapping(uint256 => uint8) private _kindPlus1;\n    uint16[8] public kindLeft = [1500, 1500, 1500, 1500, 1000, 1000, 500, 500];\n    uint256 private _poolLeft = 9000;\n    uint256 private _nextId;\n\n    event FreeMinted(address indexed wallet, uint256 qty, bool holder);\n    event PaidMinted(address indexed wallet, uint256 qty, uint256 costWei);\n    event EpicRewarded(address indexed wallet);\n\n    constructor(\n        address registry,\n        address season2_,\n        address payable payout_,\n        uint256 durationSeconds,\n        string memory baseURI_\n    ) ERC721(unicode\"山海经·八荒异兽·叁\", \"BAHUANG3\") {\n        agentId = IBalanceOf(registry);\n        season2 = IBalanceOf(season2_);\n        payout = payout_;\n        mintStart = block.timestamp;\n        mintEnd = block.timestamp + durationSeconds;\n        baseURI = baseURI_;\n    }\n\n    modifier mintOpen() {\n        require(block.timestamp < mintEnd, \"mint ended\");\n        require(agentId.balanceOf(msg.sender) > 0, \"need .ai Agent ID\");\n        _;\n    }\n\n    // ---------- 铸造 ----------\n\n    function freeMint() public mintOpen {\n        uint256 allow = freeAllowance(msg.sender);\n        uint256 left = allow > freeCount[msg.sender] ? allow - freeCount[msg.sender] : 0;\n        require(left > 0, \"free used\");\n        uint256 globalLeft = FREE_CAP - freeMinted;\n        require(globalLeft > 0, \"free sold out\");\n        if (left > globalLeft) left = globalLeft;\n        freeCount[msg.sender] += uint8(left);\n        freeMinted += left;\n        points[msg.sender] += left;\n        totalPoints += left;\n        for (uint256 i; i < left; ++i) _mintBeast(msg.sender);\n        emit FreeMinted(msg.sender, left, allow == FREE_PER_HOLDER);\n    }\n\n    /// 与 freeMint() 相同，方便只认 mint() 的机器人\n    function mint() external {\n        freeMint();\n    }\n\n    function paidMint(uint256 qty) external payable mintOpen {\n        require(qty > 0, \"qty 0\");\n        require(paidCount[msg.sender] + qty <= PAID_PER_WALLET, \"max 20 paid\");\n        require(paidMinted + qty <= PAID_CAP, \"paid sold out\");\n        uint256 cost = costWei(qty);\n        require(msg.value >= cost, \"underpaid\");\n\n        uint256 before = paidCount[msg.sender];\n        paidCount[msg.sender] += uint8(qty);\n        paidMinted += qty;\n        totalRevenueWei += cost;\n        points[msg.sender] += 2 * qty;\n        totalPoints += 2 * qty;\n        for (uint256 i; i < qty; ++i) _mintBeast(msg.sender);\n\n        if (before < EPIC_AT && before + qty >= EPIC_AT) {\n            _mintEpic(msg.sender, EPIC_ZHULONG);\n            _mintEpic(msg.sender, EPIC_YINGLONG);\n            emit EpicRewarded(msg.sender);\n        }\n        emit PaidMinted(msg.sender, qty, cost);\n\n        (bool ok, ) = payout.call{value: cost}(\"\");\n        require(ok, \"payout failed\");\n        uint256 refund = msg.value - cost;\n        if (refund > 0) {\n            (bool r, ) = payable(msg.sender).call{value: refund}(\"\");\n            require(r, \"refund failed\");\n        }\n    }\n\n    // ---------- 只读 ----------\n\n    function isSeason2Holder(address wallet) public view returns (bool) {\n        return season2.balanceOf(wallet) > 0;\n    }\n\n    function freeAllowance(address wallet) public view returns (uint256) {\n        return isSeason2Holder(wallet) ? FREE_PER_HOLDER : FREE_PER_WALLET;\n    }\n\n    /// 第 n 张付费卡（从 1 起）的价格\n    function priceAt(uint256 n) public pure returns (uint256) {\n        return n <= TIER1_END ? PRICE1 : PRICE2;\n    }\n\n    /// 接下来 qty 张付费卡的总价（跨档自动分档计算）\n    function costWei(uint256 qty) public view returns (uint256 cost) {\n        for (uint256 i = 1; i <= qty; ++i) cost += priceAt(paidMinted + i);\n    }\n\n    function mintPriceWei() external view returns (uint256) {\n        return costWei(1);\n    }\n\n    function quote(address wallet, uint256 qty)\n        external\n        view\n        returns (uint256 freeLeft, uint256 paidLeft, uint256 cost, bool eligible, bool open, bool holder)\n    {\n        uint256 allow = freeAllowance(wallet);\n        uint256 fl = allow > freeCount[wallet] ? allow - freeCount[wallet] : 0;\n        uint256 fg = FREE_CAP - freeMinted;\n        freeLeft = fl < fg ? fl : fg;\n        uint256 pl = PAID_PER_WALLET - paidCount[wallet];\n        uint256 pg = PAID_CAP - paidMinted;\n        paidLeft = pl < pg ? pl : pg;\n        cost = costWei(qty);\n        eligible = agentId.balanceOf(wallet) > 0;\n        open = block.timestamp < mintEnd;\n        holder = allow == FREE_PER_HOLDER;\n    }\n\n    function totalMinted() external view returns (uint256) {\n        return freeMinted + paidMinted;\n    }\n\n    function tokenURI(uint256 id) public view override returns (string memory) {\n        return string.concat(baseURI, uint256(beastOf(id)).toString(), \".json\");\n    }\n\n    function beastOf(uint256 id) public view returns (uint8) {\n        _requireOwned(id);\n        return _kindPlus1[id] - 1;\n    }\n\n    // ---------- 内部 ----------\n\n    /// 按剩余配额加权抽种类，保证稀有度总数固定（随机数来自 prevrandao，出块者可影响）\n    function _mintBeast(address to) internal {\n        uint256 tokenId = ++_nextId;\n        uint256 pick = uint256(keccak256(abi.encode(block.prevrandao, to, tokenId))) % _poolLeft;\n        uint8 kind;\n        for (uint8 k; k < BEAST_TYPES; ++k) {\n            if (pick < kindLeft[k]) { kind = k; break; }\n            pick -= kindLeft[k];\n        }\n        kindLeft[kind] -= 1;\n        _poolLeft -= 1;\n        _kindPlus1[tokenId] = kind + 1;\n        _mint(to, tokenId);\n    }\n\n    function _mintEpic(address to, uint8 kind) internal {\n        uint256 tokenId = EPIC_BASE + (++epicMinted);\n        _kindPlus1[tokenId] = kind + 1;\n        _mint(to, tokenId);\n    }\n}\n"},"@openzeppelin/contracts/utils/Bytes.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/Bytes.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\n\n/**\n * @dev Bytes operations.\n */\nlibrary Bytes {\n    /**\n     * @dev Forward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the first instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return indexOf(buffer, s, 0);\n    }\n\n    /**\n     * @dev Forward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or after `pos`), returns the index of the next instance\n     * * If `s` is not present in the buffer (at or after `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        uint256 length = buffer.length;\n        for (uint256 i = pos; i < length; ++i) {\n            if (bytes1(_unsafeReadBytesOffset(buffer, i)) == s) {\n                return i;\n            }\n        }\n        return type(uint256).max;\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the last instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return lastIndexOf(buffer, s, type(uint256).max);\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or before `pos`), returns the index of the previous instance\n     * * If `s` is not present in the buffer (at or before `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        unchecked {\n            uint256 length = buffer.length;\n            for (uint256 i = Math.min(Math.saturatingAdd(pos, 1), length); i > 0; --i) {\n                if (bytes1(_unsafeReadBytesOffset(buffer, i - 1)) == s) {\n                    return i - 1;\n                }\n            }\n            return type(uint256).max;\n        }\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to the end of `buffer` into a new bytes object in\n     * memory.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return slice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to `end` (excluded) into a new bytes object in\n     * memory. The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // allocate and copy\n        bytes memory result = new bytes(end - start);\n        assembly (\"memory-safe\") {\n            mcopy(add(result, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to the end of `buffer` to the start of that buffer,\n     * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:].\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     */\n    function splice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return splice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to `end` (excluded) to the start of that buffer,\n     * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:end].\n     * The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     */\n    function splice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // move and resize\n        assembly (\"memory-safe\") {\n            mcopy(add(buffer, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n            mstore(buffer, sub(end, start))\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Replaces bytes in `buffer` starting at `pos` with all bytes from `replacement`.\n     *\n     * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`).\n     * If `pos >= buffer.length`, no replacement occurs and the buffer is returned unchanged.\n     *\n     * NOTE: This function modifies the provided buffer in place.\n     */\n    function replace(bytes memory buffer, uint256 pos, bytes memory replacement) internal pure returns (bytes memory) {\n        return replace(buffer, pos, replacement, 0, replacement.length);\n    }\n\n    /**\n     * @dev Replaces bytes in `buffer` starting at `pos` with bytes from `replacement` starting at `offset`.\n     * Copies at most `length` bytes from `replacement` to `buffer`.\n     *\n     * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`, `offset` is\n     * clamped to `[0, replacement.length]`, and `length` is clamped to `min(length, replacement.length - offset,\n     * buffer.length - pos))`. If `pos >= buffer.length` or `offset >= replacement.length`, no replacement occurs\n     * and the buffer is returned unchanged.\n     *\n     * NOTE: This function modifies the provided buffer in place.\n     */\n    function replace(\n        bytes memory buffer,\n        uint256 pos,\n        bytes memory replacement,\n        uint256 offset,\n        uint256 length\n    ) internal pure returns (bytes memory) {\n        // sanitize\n        pos = Math.min(pos, buffer.length);\n        offset = Math.min(offset, replacement.length);\n        length = Math.min(length, Math.min(replacement.length - offset, buffer.length - pos));\n\n        // replace\n        assembly (\"memory-safe\") {\n            mcopy(add(add(buffer, 0x20), pos), add(add(replacement, 0x20), offset), length)\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Concatenate an array of bytes into a single bytes object.\n     *\n     * For fixed bytes types, we recommend using the solidity built-in `bytes.concat` or (equivalent)\n     * `abi.encodePacked`.\n     *\n     * NOTE: this could be done in assembly with a single loop that expands starting at the FMP, but that would be\n     * significantly less readable. It might be worth benchmarking the savings of the full-assembly approach.\n     */\n    function concat(bytes[] memory buffers) internal pure returns (bytes memory) {\n        uint256 length = 0;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            length += buffers[i].length;\n        }\n\n        bytes memory result = new bytes(length);\n\n        uint256 offset = 0x20;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            bytes memory input = buffers[i];\n            assembly (\"memory-safe\") {\n                mcopy(add(result, offset), add(input, 0x20), mload(input))\n            }\n            unchecked {\n                offset += input.length;\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Split each byte in `input` into two nibbles (4 bits each)\n     *\n     * Example: hex\"01234567\" → hex\"0001020304050607\"\n     */\n    function toNibbles(bytes memory input) internal pure returns (bytes memory output) {\n        assembly (\"memory-safe\") {\n            let length := mload(input)\n            output := mload(0x40)\n            mstore(0x40, add(add(output, 0x20), mul(length, 2)))\n            mstore(output, mul(length, 2))\n            for {\n                let i := 0\n            } lt(i, length) {\n                i := add(i, 0x10)\n            } {\n                let chunk := shr(128, mload(add(add(input, 0x20), i)))\n                chunk := and(\n                    0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff,\n                    or(shl(64, chunk), chunk)\n                )\n                chunk := and(\n                    0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff,\n                    or(shl(32, chunk), chunk)\n                )\n                chunk := and(\n                    0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff,\n                    or(shl(16, chunk), chunk)\n                )\n                chunk := and(\n                    0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff,\n                    or(shl(8, chunk), chunk)\n                )\n                chunk := and(\n                    0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f,\n                    or(shl(4, chunk), chunk)\n                )\n                mstore(add(add(output, 0x20), mul(i, 2)), chunk)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns true if the two byte buffers are equal.\n     */\n    function equal(bytes memory a, bytes memory b) internal pure returns (bool) {\n        return a.length == b.length && keccak256(a) == keccak256(b);\n    }\n\n    /**\n     * @dev Reverses the byte order of a bytes32 value, converting between little-endian and big-endian.\n     * Inspired by https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel[Reverse Parallel]\n     */\n    function reverseBytes32(bytes32 value) internal pure returns (bytes32) {\n        value = // swap bytes\n            ((value >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        value = // swap 8-byte long pairs\n            ((value >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |\n            ((value & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);\n        return (value >> 128) | (value << 128); // swap 16-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 128-bit values.\n    function reverseBytes16(bytes16 value) internal pure returns (bytes16) {\n        value = // swap bytes\n            ((value & 0xFF00FF00FF00FF00FF00FF00FF00FF00) >> 8) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value & 0xFFFF0000FFFF0000FFFF0000FFFF0000) >> 16) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value & 0xFFFFFFFF00000000FFFFFFFF00000000) >> 32) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        return (value >> 64) | (value << 64); // swap 8-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 64-bit values.\n    function reverseBytes8(bytes8 value) internal pure returns (bytes8) {\n        value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8); // swap bytes\n        value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16); // swap 2-byte long pairs\n        return (value >> 32) | (value << 32); // swap 4-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 32-bit values.\n    function reverseBytes4(bytes4 value) internal pure returns (bytes4) {\n        value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); // swap bytes\n        return (value >> 16) | (value << 16); // swap 2-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 16-bit values.\n    function reverseBytes2(bytes2 value) internal pure returns (bytes2) {\n        return (value >> 8) | (value << 8);\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits a bytes array. Returns `8 * buffer.length`\n     * if the buffer is all zeros.\n     */\n    function clz(bytes memory buffer) internal pure returns (uint256) {\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            bytes32 chunk = _unsafeReadBytesOffset(buffer, i);\n            if (chunk != bytes32(0)) {\n                return Math.min(8 * i + Math.clz(uint256(chunk)), 8 * buffer.length);\n            }\n        }\n        return 8 * buffer.length;\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n *\n * _Available since v5.1._\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/Strings.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SafeCast} from \"./math/SafeCast.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\nimport {Bytes} from \"./Bytes.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    using SafeCast for *;\n\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n    uint256 private constant SPECIAL_CHARS_LOOKUP =\n        0xffffffff | // first 32 bits corresponding to the control characters (U+0000 to U+001F)\n            (1 << 0x22) | // double quote\n            (1 << 0x5c); // backslash\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev The string being parsed contains characters that are not in scope of the given base.\n     */\n    error StringsInvalidChar();\n\n    /**\n     * @dev The string being parsed is not a properly formatted address.\n     */\n    error StringsInvalidAddressFormat();\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            assembly (\"memory-safe\") {\n                ptr := add(add(buffer, 0x20), length)\n            }\n            while (true) {\n                ptr--;\n                assembly (\"memory-safe\") {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `bytes` buffer to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(bytes memory input) internal pure returns (string memory) {\n        unchecked {\n            bytes memory buffer = new bytes(2 * input.length + 2);\n            buffer[0] = \"0\";\n            buffer[1] = \"x\";\n            for (uint256 i = 0; i < input.length; ++i) {\n                uint8 v = uint8(input[i]);\n                buffer[2 * i + 2] = HEX_DIGITS[v >> 4];\n                buffer[2 * i + 3] = HEX_DIGITS[v & 0xf];\n            }\n            return string(buffer);\n        }\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return Bytes.equal(bytes(a), bytes(b));\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input) internal pure returns (uint256) {\n        return parseUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        uint256 result = 0;\n        for (uint256 i = begin; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 9) return (false, 0);\n            result *= 10;\n            result += chr;\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `int256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input) internal pure returns (int256) {\n        return parseInt(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {\n        (bool success, int256 value) = tryParseInt(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if\n     * the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {\n        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    uint256 private constant ABS_MIN_INT256 = 2 ** 255;\n\n    /**\n     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character or if the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, int256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseIntUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseIntUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, int256 value) {\n        bytes memory buffer = bytes(input);\n\n        // Check presence of a negative sign.\n        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        bool positiveSign = sign == bytes1(\"+\");\n        bool negativeSign = sign == bytes1(\"-\");\n        uint256 offset = (positiveSign || negativeSign).toUint();\n\n        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);\n\n        if (absSuccess && absValue < ABS_MIN_INT256) {\n            return (true, negativeSign ? -int256(absValue) : int256(absValue));\n        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {\n            return (true, type(int256).min);\n        } else return (false, 0);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input) internal pure returns (uint256) {\n        return parseHexUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseHexUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an\n     * invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseHexUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseHexUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        // skip 0x prefix if present\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 offset = hasPrefix.toUint() * 2;\n\n        uint256 result = 0;\n        for (uint256 i = begin + offset; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 15) return (false, 0);\n            result *= 16;\n            unchecked {\n                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).\n                // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.\n                result += chr;\n            }\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as an `address`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input) internal pure returns (address) {\n        return parseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {\n        (bool success, address value) = tryParseAddress(input, begin, end);\n        if (!success) revert StringsInvalidAddressFormat();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly\n     * formatted address. See {parseAddress-string} requirements.\n     */\n    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {\n        return tryParseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly\n     * formatted address. See {parseAddress-string-uint256-uint256} requirements.\n     */\n    function tryParseAddress(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, address value) {\n        if (end > bytes(input).length || begin > end) return (false, address(0));\n\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;\n\n        // check that input is the correct length\n        if (end - begin == expectedLength) {\n            // length guarantees that this does not overflow, and value is at most type(uint160).max\n            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);\n            return (s, address(uint160(v)));\n        } else {\n            return (false, address(0));\n        }\n    }\n\n    function _tryParseChr(bytes1 chr) private pure returns (uint8) {\n        uint8 value = uint8(chr);\n\n        // Try to parse `chr`:\n        // - Case 1: [0-9]\n        // - Case 2: [a-f]\n        // - Case 3: [A-F]\n        // - otherwise not supported\n        unchecked {\n            if (value > 47 && value < 58) value -= 48;\n            else if (value > 96 && value < 103) value -= 87;\n            else if (value > 64 && value < 71) value -= 55;\n            else return type(uint8).max;\n        }\n\n        return value;\n    }\n\n    /**\n     * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.\n     *\n     * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.\n     *\n     * NOTE: This function escapes backslashes (including those in \\uXXXX sequences) and the characters in ranges\n     * defined in section 2.5 of RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). All control characters in U+0000\n     * to U+001F are escaped (\\b, \\t, \\n, \\f, \\r use short form; others use \\u00XX). ECMAScript's `JSON.parse` does\n     * recover escaped unicode characters that are not in this range, but other tooling may provide different results.\n     */\n    function escapeJSON(string memory input) internal pure returns (string memory) {\n        bytes memory buffer = bytes(input);\n\n        // Put output at the FMP. Memory will be reserved later when we figure out the actual length of the escaped\n        // string. All write are done using _unsafeWriteBytesOffset, which avoid the (expensive) length checks for\n        // each character written.\n        bytes memory output;\n        assembly (\"memory-safe\") {\n            output := mload(0x40)\n        }\n        uint256 outputLength = 0;\n\n        for (uint256 i = 0; i < buffer.length; ++i) {\n            uint8 char = uint8(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (((SPECIAL_CHARS_LOOKUP & (1 << char)) != 0)) {\n                _unsafeWriteBytesOffset(output, outputLength++, \"\\\\\");\n                if (char == 0x08) _unsafeWriteBytesOffset(output, outputLength++, \"b\");\n                else if (char == 0x09) _unsafeWriteBytesOffset(output, outputLength++, \"t\");\n                else if (char == 0x0a) _unsafeWriteBytesOffset(output, outputLength++, \"n\");\n                else if (char == 0x0c) _unsafeWriteBytesOffset(output, outputLength++, \"f\");\n                else if (char == 0x0d) _unsafeWriteBytesOffset(output, outputLength++, \"r\");\n                else if (char == 0x5c) _unsafeWriteBytesOffset(output, outputLength++, \"\\\\\");\n                else if (char == 0x22) {\n                    // solhint-disable-next-line quotes\n                    _unsafeWriteBytesOffset(output, outputLength++, '\"');\n                } else {\n                    // U+0000 to U+001F without short form: output \\u00XX\n                    _unsafeWriteBytesOffset(output, outputLength++, \"u\");\n                    _unsafeWriteBytesOffset(output, outputLength++, \"0\");\n                    _unsafeWriteBytesOffset(output, outputLength++, \"0\");\n                    _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char >> 4]);\n                    _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char & 0x0f]);\n                }\n            } else {\n                _unsafeWriteBytesOffset(output, outputLength++, bytes1(char));\n            }\n        }\n        // write the actual length and reserve memory\n        assembly (\"memory-safe\") {\n            mstore(output, outputLength)\n            mstore(0x40, add(output, add(outputLength, 0x20)))\n        }\n\n        return string(output);\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n\n    /**\n     * @dev Write a bytes1 to a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeWriteBytesOffset(bytes memory buffer, uint256 offset, bytes1 value) private pure {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            mstore8(add(add(buffer, 0x20), offset), shr(248, value))\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Return the 512-bit addition of two uint256.\n     *\n     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.\n     */\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        assembly (\"memory-safe\") {\n            low := add(a, b)\n            high := lt(low, a)\n        }\n    }\n\n    /**\n     * @dev Return the 512-bit multiplication of two uint256.\n     *\n     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.\n     */\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n        // variables such that product = high * 2²⁵⁶ + low.\n        assembly (\"memory-safe\") {\n            let mm := mulmod(a, b, not(0))\n            low := mul(a, b)\n            high := sub(sub(mm, low), lt(mm, low))\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            success = c >= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a - b;\n            success = c <= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a * b;\n            assembly (\"memory-safe\") {\n                // Only true when the multiplication doesn't overflow\n                // (c / a == b) || (a == 0)\n                success := or(eq(div(c, a), b), iszero(a))\n            }\n            // equivalent to: success ? c : 0\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `DIV` opcode returns zero when the denominator is 0.\n                result := div(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `MOD` opcode returns zero when the denominator is 0.\n                result := mod(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryAdd(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\n     */\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\n        (, uint256 result) = trySub(a, b);\n        return result;\n    }\n\n    /**\n     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryMul(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // (a + b) / 2 can overflow.\n            return (a & b) + (a ^ b) / 2;\n        }\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (high == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return low / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= high) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [high low].\n            uint256 remainder;\n            assembly (\"memory-safe\") {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                high := sub(high, gt(remainder, low))\n                low := sub(low, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly (\"memory-safe\") {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [high low] by twos.\n                low := div(low, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from high into low.\n            low |= high * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high\n            // is no longer required.\n            result = low * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n            if (high >= 1 << n) {\n                Panic.panic(Panic.UNDER_OVERFLOW);\n            }\n            return (high << (256 - n)) | (low >> n);\n        }\n    }\n\n    /**\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory buffer) private pure returns (bool) {\n        uint256 chunk;\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            // See _unsafeReadBytesOffset from utils/Bytes.sol\n            assembly (\"memory-safe\") {\n                chunk := mload(add(add(buffer, 0x20), i))\n            }\n            if (chunk >> (8 * saturatingSub(i + 0x20, buffer.length)) != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // If upper 8 bits of 16-bit half set, add 8 to result\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\n        // If upper 4 bits of 8-bit half set, add 4 to result\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\n\n        // Shifts value right by the current result and use it as an index into this lookup table:\n        //\n        // | x (4 bits) |  index  | table[index] = MSB position |\n        // |------------|---------|-----------------------------|\n        // |    0000    |    0    |        table[0] = 0         |\n        // |    0001    |    1    |        table[1] = 0         |\n        // |    0010    |    2    |        table[2] = 1         |\n        // |    0011    |    3    |        table[3] = 1         |\n        // |    0100    |    4    |        table[4] = 2         |\n        // |    0101    |    5    |        table[5] = 2         |\n        // |    0110    |    6    |        table[6] = 2         |\n        // |    0111    |    7    |        table[7] = 2         |\n        // |    1000    |    8    |        table[8] = 3         |\n        // |    1001    |    9    |        table[9] = 3         |\n        // |    1010    |   10    |        table[10] = 3        |\n        // |    1011    |   11    |        table[11] = 3        |\n        // |    1100    |   12    |        table[12] = 3        |\n        // |    1101    |   13    |        table[13] = 3        |\n        // |    1110    |   14    |        table[14] = 3        |\n        // |    1111    |   15    |        table[15] = 3        |\n        //\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the first 16 bytes (most significant half).\n        assembly (\"memory-safe\") {\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits in a uint256.\n     */\n    function clz(uint256 x) internal pure returns (uint256) {\n        return ternary(x == 0, 256, 255 - log2(x));\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.24;\n\nimport {IERC721} from \"./IERC721.sol\";\nimport {IERC721Metadata} from \"./extensions/IERC721Metadata.sol\";\nimport {ERC721Utils} from \"./utils/ERC721Utils.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {Strings} from \"../../utils/Strings.sol\";\nimport {IERC165, ERC165} from \"../../utils/introspection/ERC165.sol\";\nimport {IERC721Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\nabstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {\n    using Strings for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    mapping(uint256 tokenId => address) private _owners;\n\n    mapping(address owner => uint256) private _balances;\n\n    mapping(uint256 tokenId => address) private _tokenApprovals;\n\n    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return\n            interfaceId == type(IERC721).interfaceId ||\n            interfaceId == type(IERC721Metadata).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /// @inheritdoc IERC721\n    function balanceOf(address owner) public view virtual returns (uint256) {\n        if (owner == address(0)) {\n            revert ERC721InvalidOwner(address(0));\n        }\n        return _balances[owner];\n    }\n\n    /// @inheritdoc IERC721\n    function ownerOf(uint256 tokenId) public view virtual returns (address) {\n        return _requireOwned(tokenId);\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {\n        _requireOwned(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /// @inheritdoc IERC721\n    function approve(address to, uint256 tokenId) public virtual {\n        _approve(to, tokenId, _msgSender());\n    }\n\n    /// @inheritdoc IERC721\n    function getApproved(uint256 tokenId) public view virtual returns (address) {\n        _requireOwned(tokenId);\n\n        return _getApproved(tokenId);\n    }\n\n    /// @inheritdoc IERC721\n    function setApprovalForAll(address operator, bool approved) public virtual {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /// @inheritdoc IERC721\n    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /// @inheritdoc IERC721\n    function transferFrom(address from, address to, uint256 tokenId) public virtual {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        // Setting an \"auth\" arguments enables the `_isAuthorized` check which verifies that the token exists\n        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.\n        address previousOwner = _update(to, tokenId, _msgSender());\n        if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /// @inheritdoc IERC721\n    function safeTransferFrom(address from, address to, uint256 tokenId) public {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /// @inheritdoc IERC721\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {\n        transferFrom(from, to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     *\n     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the\n     * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances\n     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by\n     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.\n     */\n    function _getApproved(uint256 tokenId) internal view virtual returns (address) {\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in\n     * particular (ignoring whether it is owned by `owner`).\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {\n        return\n            spender != address(0) &&\n            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.\n     * Reverts if:\n     * - `spender` does not have approval from `owner` for `tokenId`.\n     * - `spender` does not have approval to manage all of `owner`'s assets.\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {\n        if (!_isAuthorized(owner, spender, tokenId)) {\n            if (owner == address(0)) {\n                revert ERC721NonexistentToken(tokenId);\n            } else {\n                revert ERC721InsufficientApproval(spender, tokenId);\n            }\n        }\n    }\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that\n     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.\n     *\n     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the\n     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership\n     * remain consistent with one another.\n     */\n    function _increaseBalance(address account, uint128 value) internal virtual {\n        unchecked {\n            _balances[account] += value;\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner\n     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that\n     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.\n     */\n    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {\n        address from = _ownerOf(tokenId);\n\n        // Perform (optional) operator check\n        if (auth != address(0)) {\n            _checkAuthorized(from, auth, tokenId);\n        }\n\n        // Execute the update\n        if (from != address(0)) {\n            // Clear approval. No need to re-authorize or emit the Approval event\n            _approve(address(0), tokenId, address(0), false);\n\n            unchecked {\n                _balances[from] -= 1;\n            }\n        }\n\n        if (to != address(0)) {\n            unchecked {\n                _balances[to] += 1;\n            }\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        return from;\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner != address(0)) {\n            revert ERC721InvalidSender(address(0));\n        }\n    }\n\n    /**\n     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal {\n        address previousOwner = _update(address(0), tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        } else if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients\n     * are aware of the ERC-721 standard to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is like {safeTransferFrom} in the sense that it invokes\n     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `tokenId` token must exist and be owned by `from`.\n     * - `to` cannot be the zero address.\n     * - `from` cannot be the zero address.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId) internal {\n        _safeTransfer(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is\n     * either the owner of the token, or approved to operate on all tokens held by this owner.\n     *\n     * Emits an {Approval} event.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address to, uint256 tokenId, address auth) internal {\n        _approve(to, tokenId, auth, true);\n    }\n\n    /**\n     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not\n     * emitted in the context of transfers.\n     */\n    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {\n        // Avoid reading the owner unless necessary\n        if (emitEvent || auth != address(0)) {\n            address owner = _requireOwned(tokenId);\n\n            // We do not use _isAuthorized because single-token approvals should not be able to call approve\n            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {\n                revert ERC721InvalidApprover(auth);\n            }\n\n            if (emitEvent) {\n                emit Approval(owner, to, tokenId);\n            }\n        }\n\n        _tokenApprovals[tokenId] = to;\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Requirements:\n     * - operator can't be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        if (owner == address(0)) {\n            revert ERC721InvalidApprover(address(0));\n        }\n        if (operator == address(0)) {\n            revert ERC721InvalidOperator(operator);\n        }\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).\n     * Returns the owner.\n     *\n     * Overrides to ownership logic should be done to {_ownerOf}.\n     */\n    function _requireOwned(uint256 tokenId) internal view returns (address) {\n        address owner = _ownerOf(tokenId);\n        if (owner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n        return owner;\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in a uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in a uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev A uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        assembly (\"memory-safe\") {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC-721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n     *   {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)\n\npragma solidity >=0.8.4;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @title ERC-721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC-721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC721/utils/ERC721Utils.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721Receiver} from \"../IERC721Receiver.sol\";\nimport {IERC721Errors} from \"../../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Library that provides common ERC-721 utility functions.\n *\n * See https://eips.ethereum.org/EIPS/eip-721[ERC-721].\n *\n * _Available since v5.1._\n */\nlibrary ERC721Utils {\n    /**\n     * @dev Performs an acceptance check for the provided `operator` by calling {IERC721Receiver-onERC721Received}\n     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).\n     *\n     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).\n     * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept\n     * the transfer.\n     */\n    function checkOnERC721Received(\n        address operator,\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes memory data\n    ) internal {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) {\n                if (retval != IERC721Receiver.onERC721Received.selector) {\n                    // Token rejected\n                    revert IERC721Errors.ERC721InvalidReceiver(to);\n                }\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    // non-IERC721Receiver implementer\n                    revert IERC721Errors.ERC721InvalidReceiver(to);\n                } else {\n                    assembly (\"memory-safe\") {\n                        revert(add(reason, 0x20), mload(reason))\n                    }\n                }\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC721} from \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"}},"language":"Solidity","settings":{"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun"}},"stdJsonOutput":{"sources":{"BahuangS3.sol":{"id":15},"@openzeppelin/contracts/utils/Bytes.sol":{"id":6},"@openzeppelin/contracts/utils/Panic.sol":{"id":8},"@openzeppelin/contracts/utils/Context.sol":{"id":7},"@openzeppelin/contracts/utils/Strings.sol":{"id":9},"@openzeppelin/contracts/utils/math/Math.sol":{"id":12},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"id":1},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"id":13},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"id":2},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"id":14},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":0},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":10},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":11},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"id":3},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"id":5},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"id":4}},"contracts":{"BahuangS3.sol":{"BahuangS3":{"abi":[{"type":"constructor","inputs":[{"name":"registry","type":"address","internalType":"address"},{"name":"season2_","type":"address","internalType":"address"},{"name":"payout_","type":"address","internalType":"address payable"},{"name":"durationSeconds","type":"uint256","internalType":"uint256"},{"name":"baseURI_","type":"string","internalType":"string"}],"stateMutability":"nonpayable"},{"name":"ERC721IncorrectOwner","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InsufficientApproval","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"ERC721InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOperator","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC721NonexistentToken","type":"error","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"ApprovalForAll","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"operator","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"EpicRewarded","type":"event","inputs":[{"name":"wallet","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"FreeMinted","type":"event","inputs":[{"name":"wallet","type":"address","indexed":true,"internalType":"address"},{"name":"qty","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"holder","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"PaidMinted","type":"event","inputs":[{"name":"wallet","type":"address","indexed":true,"internalType":"address"},{"name":"qty","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"costWei","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":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"BEAST_TYPES","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"EPIC_AT","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"EPIC_YINGLONG","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"EPIC_ZHULONG","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"FREE_CAP","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"FREE_PER_HOLDER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"FREE_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PAID_CAP","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PAID_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PRICE1","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PRICE2","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"TIER1_END","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"agentId","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IBalanceOf"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"beastOf","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"costWei","type":"function","inputs":[{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"cost","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"epicMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freeAllowance","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freeCount","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"freeMint","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"freeMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"isApprovedForAll","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isSeason2Holder","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"kindLeft","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint16","internalType":"uint16"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"mintEnd","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"mintPriceWei","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"mintStart","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":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"paidCount","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"paidMint","type":"function","inputs":[{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"paidMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"payout","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address payable"}],"stateMutability":"view"},{"name":"points","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"priceAt","type":"function","inputs":[{"name":"n","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"quote","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"freeLeft","type":"uint256","internalType":"uint256"},{"name":"paidLeft","type":"uint256","internalType":"uint256"},{"name":"cost","type":"uint256","internalType":"uint256"},{"name":"eligible","type":"bool","internalType":"bool"},{"name":"open","type":"bool","internalType":"bool"},{"name":"holder","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"season2","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IBalanceOf"}],"stateMutability":"view"},{"name":"setApprovalForAll","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"approved","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalPoints","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalRevenueWei","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.24+commit.e11b9ed9\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"registry\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"season2_\",\"type\":\"address\"},{\"internalType\":\"address payable\",\"name\":\"payout_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"durationSeconds\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"baseURI_\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"ERC721IncorrectOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ERC721InsufficientApproval\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"approver\",\"type\":\"address\"}],\"name\":\"ERC721InvalidApprover\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"ERC721InvalidOperator\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"ERC721InvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"ERC721InvalidReceiver\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ERC721InvalidSender\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ERC721NonexistentToken\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"}],\"name\":\"EpicRewarded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"qty\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"holder\",\"type\":\"bool\"}],\"name\":\"FreeMinted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"qty\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"costWei\",\"type\":\"uint256\"}],\"name\":\"PaidMinted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BEAST_TYPES\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EPIC_AT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EPIC_YINGLONG\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EPIC_ZHULONG\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FREE_CAP\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FREE_PER_HOLDER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FREE_PER_WALLET\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PAID_CAP\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PAID_PER_WALLET\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PRICE1\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PRICE2\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TIER1_END\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"agentId\",\"outputs\":[{\"internalType\":\"contract IBalanceOf\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"beastOf\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"qty\",\"type\":\"uint256\"}],\"name\":\"costWei\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"cost\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"epicMinted\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"}],\"name\":\"freeAllowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"freeCount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"freeMint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"freeMinted\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"}],\"name\":\"isSeason2Holder\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"kindLeft\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintEnd\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintPriceWei\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintStart\",\"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\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"paidCount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"qty\",\"type\":\"uint256\"}],\"name\":\"paidMint\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paidMinted\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"payout\",\"outputs\":[{\"internalType\":\"address payable\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"points\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"n\",\"type\":\"uint256\"}],\"name\":\"priceAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"qty\",\"type\":\"uint256\"}],\"name\":\"quote\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"freeLeft\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"paidLeft\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"cost\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"eligible\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"open\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"holder\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"season2\",\"outputs\":[{\"internalType\":\"contract IBalanceOf\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalMinted\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalPoints\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalRevenueWei\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"ERC721IncorrectOwner(address,uint256,address)\":[{\"details\":\"Indicates an error related to the ownership over a particular token. Used in transfers.\",\"params\":{\"owner\":\"Address of the current owner of a token.\",\"sender\":\"Address whose tokens are being transferred.\",\"tokenId\":\"Identifier number of a token.\"}}],\"ERC721InsufficientApproval(address,uint256)\":[{\"details\":\"Indicates a failure with the `operator`’s approval. Used in transfers.\",\"params\":{\"operator\":\"Address that may be allowed to operate on tokens without being their owner.\",\"tokenId\":\"Identifier number of a token.\"}}],\"ERC721InvalidApprover(address)\":[{\"details\":\"Indicates a failure with the `approver` of a token to be approved. Used in approvals.\",\"params\":{\"approver\":\"Address initiating an approval operation.\"}}],\"ERC721InvalidOperator(address)\":[{\"details\":\"Indicates a failure with the `operator` to be approved. Used in approvals.\",\"params\":{\"operator\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"ERC721InvalidOwner(address)\":[{\"details\":\"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. Used in balance queries.\",\"params\":{\"owner\":\"Address of the current owner of a token.\"}}],\"ERC721InvalidReceiver(address)\":[{\"details\":\"Indicates a failure with the token `receiver`. Used in transfers.\",\"params\":{\"receiver\":\"Address to which tokens are being transferred.\"}}],\"ERC721InvalidSender(address)\":[{\"details\":\"Indicates a failure with the token `sender`. Used in transfers.\",\"params\":{\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC721NonexistentToken(uint256)\":[{\"details\":\"Indicates a `tokenId` whose `owner` is the zero address.\",\"params\":{\"tokenId\":\"Identifier number of a token.\"}}]},\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when `owner` enables `approved` to manage the `tokenId` token.\"},\"ApprovalForAll(address,address,bool)\":{\"details\":\"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `tokenId` token is transferred from `from` to `to`.\"}},\"kind\":\"dev\",\"methods\":{\"approve(address,uint256)\":{\"details\":\"Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.\"},\"balanceOf(address)\":{\"details\":\"Returns the number of tokens in ``owner``'s account.\"},\"getApproved(uint256)\":{\"details\":\"Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.\"},\"isApprovedForAll(address,address)\":{\"details\":\"Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}\"},\"name()\":{\"details\":\"Returns the token collection name.\"},\"ownerOf(uint256)\":{\"details\":\"Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.\"},\"safeTransferFrom(address,address,uint256)\":{\"details\":\"Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or   {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event.\"},\"safeTransferFrom(address,address,uint256,bytes)\":{\"details\":\"Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event.\"},\"setApprovalForAll(address,bool)\":{\"details\":\"Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the address zero. Emits an {ApprovalForAll} event.\"},\"supportsInterface(bytes4)\":{\"details\":\"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas.\"},\"symbol()\":{\"details\":\"Returns the token collection symbol.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"costWei(uint256)\":{\"notice\":\"接下来 qty 张付费卡的总价（跨档自动分档计算）\"},\"mint()\":{\"notice\":\"与 freeMint() 相同，方便只认 mint() 的机器人\"},\"priceAt(uint256)\":{\"notice\":\"第 n 张付费卡（从 1 起）的价格\"}},\"notice\":\"《山海经·八荒异兽·叁》 BAHUANG3 学 Agent Nakamigos（Agent ID 圈付费收入第一）的第二期打法：  - 只限持有币安 .ai Agent ID 的钱包（SPACE ID 注册表 balanceOf > 0）  - 免费：freeMint()（或 mint()），value = 0，一次调用领完。普通钱包 2 张；持有《八荒异兽·贰》的钱包 5 张。全局 6,000 张  - 付费：paidMint(qty)，固定 BNB 价：付费第 1–1,500 张每张 0.0005 BNB，之后 0.0009 BNB。每钱包最多 20 张，全局 3,000 张，多付退回  - 积分：免费每张 1 分、付费每张 2 分，记在链上 points(wallet)，供下一季读取（就像本季读取「贰」的持有人）  - 一个钱包付费满 10 张，加送 烛龙、应龙 两张史诗卡  - 无 owner、无管理函数、无提现：收入每笔直接打给 payout；铸造窗口部署时写死\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"BahuangS3.sol\":\"BahuangS3\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/interfaces/draft-IERC6093.sol\":{\"keccak256\":\"0x1b88b3fb3d85ba5496d7d5f396f83ee1fddcdd6762059ff65992655b67920998\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://89393bb3212da1c0889601b9706a07b39419ddc4d2faab9eaf6e7f9152cf6a1c\",\"dweb:/ipfs/QmcCfzzxv1Bkdz1c1yF4gQCeYb6Us5BJANnzTFqawfd1HL\"]},\"@openzeppelin/contracts/token/ERC721/ERC721.sol\":{\"keccak256\":\"0xf6bb0dc431a9c50e25756412ec14cfcd4dc61dd40b8dc0e1b58ec09fce6d5564\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://eb87fef7e8ed754b8600cd5d42e4f23128059006368ffd19e4d50cc166471ee5\",\"dweb:/ipfs/Qmc1vy1cevKreGUsG7S79gyhNvDtPnNz9qG47eYVHmMKLs\"]},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"keccak256\":\"0xf78f05f3b8c9f75570e85300d7b4600d7f6f6a198449273f31d44c1641adb46f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e28b872613b45e0e801d4995aa4380be2531147bfe2d85c1d6275f1de514fba3\",\"dweb:/ipfs/QmeeFcfShHYaS3BdgVj78nxR28ZaVUwbvr66ud8bT6kzw9\"]},\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\":{\"keccak256\":\"0x88cd5e3bee2e8c36b8d9058fbcaa81ad5704281b25634122234b55ea853d8055\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8dc7e7ab5b8ea36c15027ab04221b05d1c970f47a53e9fd47ead8ca665d49c7e\",\"dweb:/ipfs/Qmeeph7fsDyfRr8vb2L8KcDEmKPb224TAayMvgqgGAnqpL\"]},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"keccak256\":\"0xf46268c37522320bb2119a5a394bc5c739a95c0c574c8d08e8c643f4d06e5c76\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://517e4b295f35b9947c72ad7379a6089439ece7bb6f4a2ea0a159da13046c039e\",\"dweb:/ipfs/QmZXzkSfLUbvujig3zVbpDHykpHhqLpvQtdiN3B5j4TA3u\"]},\"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol\":{\"keccak256\":\"0xc7efbc23214ad7dced8bf2249460f4bda114d57f6a0079f84040654280f455bd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1f5bd44efca8c8c0d74439e7b808d1f9c4af1df78f91fef8e8bbca8104645435\",\"dweb:/ipfs/Qmb42XSd8MKsEitp42sZkSFGqDRigk6QgGXtiJyJqUZJJ6\"]},\"@openzeppelin/contracts/utils/Bytes.sol\":{\"keccak256\":\"0xf80e4b96b6849936ea0fabd76cf81b13d7276295fddb1e1c07afb3ddf650b0ac\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6430007255ac11c6e9c4331a418f3af52ff66fbbae959f645301d025b20aeb08\",\"dweb:/ipfs/QmQE5fjmBBRw9ndnzJuC2uskYss1gbaR7JdazoCf1FGoBj\"]},\"@openzeppelin/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"@openzeppelin/contracts/utils/Panic.sol\":{\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a\",\"dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG\"]},\"@openzeppelin/contracts/utils/Strings.sol\":{\"keccak256\":\"0x1fdc2de9585ab0f1c417f02a873a2b6343cd64bb7ffec6b00ffa11a4a158d9e8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1ab223a3d969c6cd7610049431dd42740960c477e45878f5d8b54411f7a32bdc\",\"dweb:/ipfs/QmWumhjvhpKcwx3vDPQninsNVTc3BGvqaihkQakFkQYpaS\"]},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"keccak256\":\"0x2d9dc2fe26180f74c11c13663647d38e259e45f95eb88f57b61d2160b0109d3e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://81233d1f98060113d9922180bb0f14f8335856fe9f339134b09335e9f678c377\",\"dweb:/ipfs/QmWh6R35SarhAn4z2wH8SU456jJSYL2FgucfTFgbHJJN4E\"]},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617\",\"dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u\"]},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"keccak256\":\"0x59973a93b1f983f94e10529f46ca46544a9fec2b5f56fb1390bbe9e0dc79f857\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c55ef8f0b9719790c2ae6f81d80a59ffb89f2f0abe6bc065585bd79edce058c5\",\"dweb:/ipfs/QmNNmCbX9NjPXKqHJN8R1WC2rNeZSQrPZLd6FF6AKLyH5Y\"]},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"keccak256\":\"0xc8cae21c9ae4a46e5162ff9bf5b351d6fa6a6eba72d515f3bc1bdfeda7fdf083\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ce830ebcf28e31643caba318996db3763c36d52cd0f23798ba83c135355d45e9\",\"dweb:/ipfs/QmdGPcvptHN7UBCbUYBbRX3hiRVRFLRwno8b4uga6uFNif\"]},\"@openzeppelin/contracts/utils/math/SignedMath.sol\":{\"keccak256\":\"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://db5fbb3dddd8b7047465b62575d96231ba8a2774d37fb4737fbf23340fabbb03\",\"dweb:/ipfs/QmVUSvooZKEdEdap619tcJjTLcAuH6QBdZqAzWwnAXZAWJ\"]},\"BahuangS3.sol\":{\"keccak256\":\"0xbbe2af98a85e3ac4d97bef3ed4bd181a814172fce9b7d96d0e46d1aca75d3cc0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2025ec07e45ce50bbfb5f16c1e69884ad35a483784840492acb46a1e66a14079\",\"dweb:/ipfs/QmPVX1Y7BQu93Tk8VnJDAwEJM1ja8urBo9pNtad8gyD1UW\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"《山海经·八荒异兽·叁》 BAHUANG3 学 Agent Nakamigos（Agent ID 圈付费收入第一）的第二期打法：  - 只限持有币安 .ai Agent ID 的钱包（SPACE ID 注册表 balanceOf > 0）  - 免费：freeMint()（或 mint()），value = 0，一次调用领完。普通钱包 2 张；持有《八荒异兽·贰》的钱包 5 张。全局 6,000 张  - 付费：paidMint(qty)，固定 BNB 价：付费第 1–1,500 张每张 0.0005 BNB，之后 0.0009 BNB。每钱包最多 20 张，全局 3,000 张，多付退回  - 积分：免费每张 1 分、付费每张 2 分，记在链上 points(wallet)，供下一季读取（就像本季读取「贰」的持有人）  - 一个钱包付费满 10 张，加送 烛龙、应龙 两张史诗卡  - 无 owner、无管理函数、无提现：收入每笔直接打给 payout；铸造窗口部署时写死","methods":{"mint()":{"notice":"与 freeMint() 相同，方便只认 mint() 的机器人"},"costWei(uint256)":{"notice":"接下来 qty 张付费卡的总价（跨档自动分档计算）"},"priceAt(uint256)":{"notice":"第 n 张付费卡（从 1 起）的价格"}},"version":1},"devdoc":{"kind":"dev","errors":{"ERC721InvalidOwner(address)":[{"params":{"owner":"Address of the current owner of a token."},"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. Used in balance queries."}],"ERC721InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC721InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC721InvalidOperator(address)":[{"params":{"operator":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `operator` to be approved. Used in approvals."}],"ERC721InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"ERC721NonexistentToken(uint256)":[{"params":{"tokenId":"Identifier number of a token."},"details":"Indicates a `tokenId` whose `owner` is the zero address."}],"ERC721InsufficientApproval(address,uint256)":[{"params":{"tokenId":"Identifier number of a token.","operator":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `operator`’s approval. Used in transfers."}],"ERC721IncorrectOwner(address,uint256,address)":[{"params":{"owner":"Address of the current owner of a token.","sender":"Address whose tokens are being transferred.","tokenId":"Identifier number of a token."},"details":"Indicates an error related to the ownership over a particular token. Used in transfers."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."}},"methods":{"name()":{"details":"Returns the token collection name."},"symbol()":{"details":"Returns the token collection symbol."},"ownerOf(uint256)":{"details":"Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist."},"balanceOf(address)":{"details":"Returns the number of tokens in ``owner``'s account."},"getApproved(uint256)":{"details":"Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist."},"approve(address,uint256)":{"details":"Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event."},"supportsInterface(bytes4)":{"details":"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas."},"setApprovalForAll(address,bool)":{"details":"Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the address zero. Emits an {ApprovalForAll} event."},"isApprovedForAll(address,address)":{"details":"Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}"},"transferFrom(address,address,uint256)":{"details":"Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256)":{"details":"Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or   {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint8":{"label":"uint8","encoding":"inplace","numberOfBytes":"1"},"t_uint16":{"label":"uint16","encoding":"inplace","numberOfBytes":"2"},"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_array(t_uint16)8_storage":{"base":"t_uint16","label":"uint16[8]","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint8)":{"key":"t_address","label":"mapping(address => uint8)","value":"t_uint8","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_uint8)":{"key":"t_uint256","label":"mapping(uint256 => uint8)","value":"t_uint8","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_uint256,t_address)":{"key":"t_uint256","label":"mapping(uint256 => address)","value":"t_address","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_bool))":{"key":"t_address","label":"mapping(address => mapping(address => bool))","value":"t_mapping(t_address,t_bool)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_string_storage","astId":169,"label":"_name","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"1","type":"t_string_storage","astId":171,"label":"_symbol","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"2","type":"t_mapping(t_uint256,t_address)","astId":175,"label":"_owners","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"3","type":"t_mapping(t_address,t_uint256)","astId":179,"label":"_balances","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"4","type":"t_mapping(t_uint256,t_address)","astId":183,"label":"_tokenApprovals","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"5","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":189,"label":"_operatorApprovals","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"6","type":"t_string_storage","astId":7414,"label":"baseURI","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"7","type":"t_uint256","astId":7416,"label":"freeMinted","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"8","type":"t_uint256","astId":7418,"label":"paidMinted","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"9","type":"t_uint256","astId":7420,"label":"epicMinted","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"10","type":"t_uint256","astId":7422,"label":"totalRevenueWei","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"11","type":"t_uint256","astId":7424,"label":"totalPoints","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"12","type":"t_mapping(t_address,t_uint8)","astId":7428,"label":"freeCount","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"13","type":"t_mapping(t_address,t_uint8)","astId":7432,"label":"paidCount","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"14","type":"t_mapping(t_address,t_uint256)","astId":7436,"label":"points","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"15","type":"t_mapping(t_uint256,t_uint8)","astId":7440,"label":"_kindPlus1","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"16","type":"t_array(t_uint16)8_storage","astId":7453,"label":"kindLeft","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"17","type":"t_uint256","astId":7456,"label":"_poolLeft","offset":0,"contract":"BahuangS3.sol:BahuangS3"},{"slot":"18","type":"t_uint256","astId":7458,"label":"_nextId","offset":0,"contract":"BahuangS3.sol:BahuangS3"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"2446:74:15:-:0;1154:7005;2446:74;2475:4;1154:7005;2446:74;;;;;;;;;;;;;;;;2499:4;2446:74;;;;;;2511:3;2446:74;;;;;;;;;;;;:::i;:::-;;2554:4;2526:32;;2791:457;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1380:113:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1380:113:1;;;1454:5;1446;:13;;;;;;:::i;:::-;-1:-1:-1;1469:7:1;:17;1479:7;1469;:17;:::i;:::-;-1:-1:-1;;;;;;;;3027:30:15;;::::1;;::::0;3067;;::::1;;::::0;3107:16;::::1;;::::0;3145:15:::1;3133:27;::::0;;;3180:33:::1;::::0;3198:15;;3180:33:::1;:::i;:::-;3170:43;::::0;3223:7:::1;:18;3233:8:::0;3223:7;:18:::1;:::i;:::-;;2791:457:::0;;;;;1154:7005;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1154:7005:15;;;-1:-1:-1;1154:7005:15;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:16;-1:-1:-1;;;;;89:31:16;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:127::-;211:10;206:3;202:20;199:1;192:31;242:4;239:1;232:15;266:4;263:1;256:15;282:1509;406:6;414;422;430;438;491:3;479:9;470:7;466:23;462:33;459:53;;;508:1;505;498:12;459:53;540:9;534:16;559:31;584:5;559:31;:::i;:::-;609:5;599:15;;;633:2;680;669:9;665:18;659:25;693:33;718:7;693:33;:::i;:::-;797:2;782:18;;776:25;745:7;;-1:-1:-1;810:33:16;776:25;810:33;:::i;:::-;909:2;894:18;;888:25;957:3;942:19;;936:26;862:7;;-1:-1:-1;888:25:16;-1:-1:-1;;;;;;1011:14:16;;;1008:34;;;1038:1;1035;1028:12;1008:34;1076:6;1065:9;1061:22;1051:32;;1121:7;1114:4;1110:2;1106:13;1102:27;1092:55;;1143:1;1140;1133:12;1092:55;1172:2;1166:9;1194:2;1190;1187:10;1184:36;;;1200:18;;:::i;:::-;1275:2;1269:9;1243:2;1329:13;;-1:-1:-1;;1325:22:16;;;1349:2;1321:31;1317:40;1305:53;;;1373:18;;;1393:22;;;1370:46;1367:72;;;1419:18;;:::i;:::-;1459:10;1455:2;1448:22;1494:2;1486:6;1479:18;1534:7;1529:2;1524;1520;1516:11;1512:20;1509:33;1506:53;;;1555:1;1552;1545:12;1506:53;1577:1;1568:10;;1587:129;1601:2;1598:1;1595:9;1587:129;;;1689:10;;;1685:19;;1679:26;1658:14;;;1654:23;;1647:59;1612:10;;;;1587:129;;;1758:1;1753:2;1748;1740:6;1736:15;1732:24;1725:35;1779:6;1769:16;;;;;;;;282:1509;;;;;;;;:::o;1796:380::-;1875:1;1871:12;;;;1918;;;1939:61;;1993:4;1985:6;1981:17;1971:27;;1939:61;2046:2;2038:6;2035:14;2015:18;2012:38;2009:161;;2092:10;2087:3;2083:20;2080:1;2073:31;2127:4;2124:1;2117:15;2155:4;2152:1;2145:15;2009:161;;1796:380;;;:::o;2307:518::-;2409:2;2404:3;2401:11;2398:421;;;2445:5;2442:1;2435:16;2489:4;2486:1;2476:18;2559:2;2547:10;2543:19;2540:1;2536:27;2530:4;2526:38;2595:4;2583:10;2580:20;2577:47;;;-1:-1:-1;2618:4:16;2577:47;2673:2;2668:3;2664:12;2661:1;2657:20;2651:4;2647:31;2637:41;;2728:81;2746:2;2739:5;2736:13;2728:81;;;2805:1;2791:16;;2772:1;2761:13;2728:81;;;2732:3;;2398:421;2307:518;;;:::o;3001:1345::-;3121:10;;-1:-1:-1;;;;;3143:30:16;;3140:56;;;3176:18;;:::i;:::-;3205:97;3295:6;3255:38;3287:4;3281:11;3255:38;:::i;:::-;3249:4;3205:97;:::i;:::-;3357:4;;3414:2;3403:14;;3431:1;3426:663;;;;4133:1;4150:6;4147:89;;;-1:-1:-1;4202:19:16;;;4196:26;4147:89;-1:-1:-1;;2958:1:16;2954:11;;;2950:24;2946:29;2936:40;2982:1;2978:11;;;2933:57;4249:81;;3396:944;;3426:663;2254:1;2247:14;;;2291:4;2278:18;;-1:-1:-1;;3462:20:16;;;3580:236;3594:7;3591:1;3588:14;3580:236;;;3683:19;;;3677:26;3662:42;;3775:27;;;;3743:1;3731:14;;;;3610:19;;3580:236;;;3584:3;3844:6;3835:7;3832:19;3829:201;;;3905:19;;;3899:26;-1:-1:-1;;3988:1:16;3984:14;;;4000:3;3980:24;3976:37;3972:42;3957:58;3942:74;;3829:201;;;4076:1;4067:6;4064:1;4060:14;4056:22;4050:4;4043:36;3396:944;;;;;3001:1345;;:::o;4351:222::-;4416:9;;;4437:10;;;4434:133;;;4489:10;4484:3;4480:20;4477:1;4470:31;4524:4;4521:1;4514:15;4552:4;4549:1;4542:15;4434:133;4351:222;;;;:::o;:::-;1154:7005:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1154:7005:15:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1527:300:1;;;;;;;;;;-1:-1:-1;1527:300:1;;;;;:::i;:::-;;:::i;:::-;;;565:14:16;;558:22;540:41;;528:2;513:18;1527:300:1;;;;;;;;2263:89;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3299:154::-;;;;;;;;;;-1:-1:-1;3299:154:1;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1719:32:16;;;1701:51;;1689:2;1674:18;3299:154:1;1555:203:16;3152:113:1;;;;;;;;;;-1:-1:-1;3152:113:1;;;;;:::i;:::-;;:::i;:::-;;1692:38:15;;;;;;;;;;;;1729:1;1692:38;;;;;2372:4:16;2360:17;;;2342:36;;2330:2;2315:18;1692:38:15;2200:184:16;4184:52:15;;;;;;;;;;;;;:::i;3852:578:1:-;;;;;;;;;;-1:-1:-1;3852:578:1;;;;;:::i;:::-;;:::i;1985:34:15:-;;;;;;;;;;;;;;;;;;2868:25:16;;;2856:2;2841:18;1985:34:15;2722:177:16;1547:45:15;;;;;;;;;;;;1580:12;1547:45;;2123:25;;;;;;;;;;;;;;;;2154;;;;;;;;;;;;;;;;2349:41;;;;;;;;;;-1:-1:-1;2349:41:15;;;;;:::i;:::-;;;;;;;;;;;;;;5442:121;;;;;;;;;;-1:-1:-1;5442:121:15;;;;;:::i;:::-;;:::i;2301:42::-;;;;;;;;;;-1:-1:-1;2301:42:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;4464:132:1;;;;;;;;;;-1:-1:-1;4464:132:1;;;;;:::i;:::-;;:::i;1221:39:15:-;;;;;;;;;;;;1256:4;1221:39;;2221:26;;;;;;;;;;;;;;;;3466:647;;;;;;;;;;;;;:::i;2103:118:1:-;;;;;;;;;;-1:-1:-1;2103:118:1;;;;;:::i;:::-;;:::i;1940:39:15:-;;;;;;;;;;;;;;;4242:1157;;;;;;:::i;:::-;;:::i;2446:74::-;;;;;;;;;;-1:-1:-1;2446:74:15;;;;;:::i;:::-;;:::i;:::-;;;3493:6:16;3481:19;;;3463:38;;3451:2;3436:18;2446:74:15;3319:188:16;1861:208:1;;;;;;;;;;-1:-1:-1;1861:208:1;;;;;:::i;:::-;;:::i;1899:35:15:-;;;;;;;;;;;;;;;6222:704;;;;;;;;;;-1:-1:-1;6222:704:15;;;;;:::i;:::-;;:::i;:::-;;;;4008:25:16;;;4064:2;4049:18;;4042:34;;;;4092:18;;;4085:34;;;;4162:14;4155:22;4150:2;4135:18;;4128:50;4222:14;4215:22;4209:3;4194:19;;4187:51;4282:14;4275:22;4269:3;4254:19;;4247:51;3995:3;3980:19;6222:704:15;3739:565:16;2253:42:15;;;;;;;;;;-1:-1:-1;2253:42:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;2394:93:1;;;;;;;;;;;;;:::i;5778:114:15:-;;;;;;;;;;-1:-1:-1;5778:114:15;;;;;:::i;:::-;;:::i;2185:30::-;;;;;;;;;;;;;;;;1598:45;;;;;;;;;;;;1631:12;1598:45;;3487:144:1;;;;;;;;;;-1:-1:-1;3487:144:1;;;;;:::i;:::-;;:::i;6932:102:15:-;;;;;;;;;;;;;:::i;1501:40::-;;;;;;;;;;;;1537:4;1501:40;;1360:43;;;;;;;;;;;;1402:1;1360:43;;4630:233:1;;;;;;;;;;-1:-1:-1;4630:233:1;;;;;:::i;:::-;;:::i;5972:148:15:-;;;;;;;;;;-1:-1:-1;5972:148:15;;;;;:::i;:::-;;:::i;7209:126::-;;;;;;;;;;-1:-1:-1;7209:126:15;;;;;:::i;:::-;;:::i;7040:163::-;;;;;;;;;;-1:-1:-1;7040:163:15;;;;;:::i;:::-;;:::i;6126:90::-;;;;;;;;;;;;;:::i;1311:43::-;;;;;;;;;;;;1353:1;1311:43;;2092:25;;;;;;;;;;;;;;;;1409:44;;;;;;;;;;;;1451:2;1409:44;;1459:36;;;;;;;;;;;;1493:2;1459:36;;1736:39;;;;;;;;;;;;1774:1;1736:39;;1858:35;;;;;;;;;;;;;;;3665:153:1;;;;;;;;;;-1:-1:-1;3665:153:1;;;;;:::i;:::-;;:::i;2025:32:15:-;;;;;;;;;;;;;;;5569:152;;;;;;;;;;-1:-1:-1;5569:152:15;;;;;:::i;:::-;;:::i;1266:39::-;;;;;;;;;;;;1301:4;1266:39;;1527:300:1;1629:4;-1:-1:-1;;;;;;1664:40:1;;-1:-1:-1;;;1664:40:1;;:104;;-1:-1:-1;;;;;;;1720:48:1;;-1:-1:-1;;;1720:48:1;1664:104;:156;;;-1:-1:-1;;;;;;;;;;829:40:10;;;1784:36:1;1645:175;1527:300;-1:-1:-1;;1527:300:1:o;2263:89::-;2308:13;2340:5;2333:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2263:89;:::o;3299:154::-;3366:7;3385:22;3399:7;3385:13;:22::i;:::-;-1:-1:-1;5679:7:1;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;5705:24:1;3425:21;5609:127;3152:113;3223:35;3232:2;3236:7;735:10:7;3223:8:1;:35::i;:::-;3152:113;;:::o;4184:52:15:-;4219:10;:8;:10::i;:::-;4184:52::o;3852:578:1:-;-1:-1:-1;;;;;3946:16:1;;3942:87;;3985:33;;-1:-1:-1;;;3985:33:1;;4015:1;3985:33;;;1701:51:16;1674:18;;3985:33:1;;;;;;;;3942:87;4247:21;4271:34;4279:2;4283:7;735:10:7;4271:7:1;:34::i;:::-;4247:58;;4336:4;-1:-1:-1;;;;;4319:21:1;:13;-1:-1:-1;;;;;4319:21:1;;4315:109;;4363:50;;-1:-1:-1;;;4363:50:1;;-1:-1:-1;;;;;6844:15:16;;;4363:50:1;;;6826:34:16;6876:18;;;6869:34;;;6939:15;;6919:18;;;6912:43;6761:18;;4363:50:1;6586:375:16;4315:109:1;3932:498;3852:578;;;:::o;5442:121:15:-;5527:25;;-1:-1:-1;;;5527:25:15;;-1:-1:-1;;;;;1719:32:16;;;5527:25:15;;;1701:51:16;5504:4:15;;;;5527:7;:17;;;;1674:18:16;;5527:25:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:29;;5442:121;-1:-1:-1;;5442:121:15:o;4464:132:1:-;4550:39;4567:4;4573:2;4577:7;4550:39;;;;;;;;;;;;:16;:39::i;:::-;4464:132;;;:::o;3466:647:15:-;3310:7;3292:15;:25;3284:48;;;;-1:-1:-1;;;3284:48:15;;7357:2:16;3284:48:15;;;7339:21:16;7396:2;7376:18;;;7369:30;-1:-1:-1;;;7415:18:16;;;7408:40;7465:18;;3284:48:15;7155:334:16;3284:48:15;3350:29;;-1:-1:-1;;;3350:29:15;;3368:10;3350:29;;;1701:51:16;3382:1:15;;3350:7;-1:-1:-1;;;;;3350:17:15;;;;1674:18:16;;3350:29:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;3342:63;;;;-1:-1:-1;;;3342:63:15;;7696:2:16;3342:63:15;;;7678:21:16;7735:2;7715:18;;;7708:30;-1:-1:-1;;;7754:18:16;;;7747:47;7811:18;;3342:63:15;7494:341:16;3342:63:15;3512:13:::1;3528:25;3542:10;3528:13;:25::i;:::-;3596:10;3563:12;3586:21:::0;;;:9:::1;:21;::::0;;;;;3512:41;;-1:-1:-1;3563:12:15;3586:21:::1;;3578:29:::0;::::1;:65;;3642:1;3578:65;;;3628:10;3618:21;::::0;;;:9:::1;:21;::::0;;;;;3610:29:::1;::::0;3618:21:::1;;3610:5:::0;:29:::1;:::i;:::-;3563:80;;3668:1;3661:4;:8;3653:30;;;::::0;-1:-1:-1;;;3653:30:15;;8307:2:16;3653:30:15::1;::::0;::::1;8289:21:16::0;8346:1;8326:18;;;8319:29;-1:-1:-1;;;8364:18:16;;;8357:39;8413:18;;3653:30:15::1;8105:332:16::0;3653:30:15::1;3693:18;3725:10;;1256:4;3714:21;;;;:::i;:::-;3693:42;;3766:1;3753:10;:14;3745:40;;;::::0;-1:-1:-1;;;3745:40:15;;8644:2:16;3745:40:15::1;::::0;::::1;8626:21:16::0;8683:2;8663:18;;;8656:30;-1:-1:-1;;;8702:18:16;;;8695:43;8755:18;;3745:40:15::1;8442:337:16::0;3745:40:15::1;3806:10;3799:4;:17;3795:40;;;3825:10;3818:17;;3795:40;3855:10;3845:21;::::0;;;:9:::1;:21;::::0;;;;:36;;3876:4;;3845:21;:36:::1;::::0;3876:4;;3845:36:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;3905:4;3891:10;;:18;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;3926:10:15::1;3919:18;::::0;;;:6:::1;:18;::::0;;;;:26;;3941:4;;3919:18;:26:::1;::::0;3941:4;;3919:26:::1;:::i;:::-;;;;;;;;3970:4;3955:11;;:19;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;3989:9:15::1;::::0;-1:-1:-1;3984:53:15::1;4004:4;4000:1;:8;3984:53;;;4015:22;4026:10;4015;:22::i;:::-;4010:3;;3984:53;;;-1:-1:-1::0;4052:54:15::1;::::0;;9235:25:16;;;1402:1:15::1;4081:24:::0;::::1;9291:2:16::0;9276:18;;9269:50;4063:10:15::1;::::0;4052:54:::1;::::0;9208:18:16;4052:54:15::1;;;;;;;3502:611;;;3466:647::o:0;2103:118:1:-;2166:7;2192:22;2206:7;2192:13;:22::i;4242:1157:15:-;3310:7;3292:15;:25;3284:48;;;;-1:-1:-1;;;3284:48:15;;7357:2:16;3284:48:15;;;7339:21:16;7396:2;7376:18;;;7369:30;-1:-1:-1;;;7415:18:16;;;7408:40;7465:18;;3284:48:15;7155:334:16;3284:48:15;3350:29;;-1:-1:-1;;;3350:29:15;;3368:10;3350:29;;;1701:51:16;3382:1:15;;3350:7;-1:-1:-1;;;;;3350:17:15;;;;1674:18:16;;3350:29:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;3342:63;;;;-1:-1:-1;;;3342:63:15;;7696:2:16;3342:63:15;;;7678:21:16;7735:2;7715:18;;;7708:30;-1:-1:-1;;;7754:18:16;;;7747:47;7811:18;;3342:63:15;7494:341:16;3342:63:15;4323:1:::1;4317:3;:7;4309:25;;;::::0;-1:-1:-1;;;4309:25:15;;9532:2:16;4309:25:15::1;::::0;::::1;9514:21:16::0;9571:1;9551:18;;;9544:29;-1:-1:-1;;;9589:18:16;;;9582:35;9634:18;;4309:25:15::1;9330:328:16::0;4309:25:15::1;4362:10;4352:21;::::0;;;:9:::1;:21;::::0;;;;;1451:2:::1;::::0;4352:27:::1;::::0;4376:3;;4352:21:::1;;:27;:::i;:::-;:46;;4344:70;;;::::0;-1:-1:-1;;;4344:70:15;;9865:2:16;4344:70:15::1;::::0;::::1;9847:21:16::0;9904:2;9884:18;;;9877:30;-1:-1:-1;;;9923:18:16;;;9916:41;9974:18;;4344:70:15::1;9663:335:16::0;4344:70:15::1;1301:4;4445:3;4432:10;;:16;;;;:::i;:::-;:28;;4424:54;;;::::0;-1:-1:-1;;;4424:54:15;;10205:2:16;4424:54:15::1;::::0;::::1;10187:21:16::0;10244:2;10224:18;;;10217:30;-1:-1:-1;;;10263:18:16;;;10256:43;10316:18;;4424:54:15::1;10003:337:16::0;4424:54:15::1;4488:12;4503;4511:3;4503:7;:12::i;:::-;4488:27;;4546:4;4533:9;:17;;4525:39;;;::::0;-1:-1:-1;;;4525:39:15;;10547:2:16;4525:39:15::1;::::0;::::1;10529:21:16::0;10586:1;10566:18;;;10559:29;-1:-1:-1;;;10604:18:16;;;10597:39;10653:18;;4525:39:15::1;10345:332:16::0;4525:39:15::1;4602:10;4575:14;4592:21:::0;;;:9:::1;:21;::::0;;;;;;::::1;;::::0;4654:3;;4592:21;4623:35:::1;4654:3:::0;4592:21;4623:35:::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;4682:3;4668:10;;:17;;;;;;;:::i;:::-;;;;;;;;4714:4;4695:15;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;4750:7:15::1;::::0;-1:-1:-1;4754:3:15;4750:1:::1;:7;:::i;:::-;4735:10;4728:18;::::0;;;:6:::1;:18;::::0;;;;:29;;:18;;;:29:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;4782:7:15::1;::::0;-1:-1:-1;4786:3:15;4782:1:::1;:7;:::i;:::-;4767:11;;:22;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;4804:9:15::1;::::0;-1:-1:-1;4799:52:15::1;4819:3;4815:1;:7;4799:52;;;4829:22;4840:10;4829;:22::i;:::-;4824:3;;4799:52;;;;1493:2;4866:6;:16;:43;;;;-1:-1:-1::0;1493:2:15::1;4886:12;4895:3:::0;4886:6;:12:::1;:::i;:::-;:23;;4866:43;4862:202;;;4925:35;4935:10;1729:1;4925:9;:35::i;:::-;4974:36;4984:10;1774:1;4974:9;:36::i;:::-;5029:24;::::0;5042:10:::1;::::0;5029:24:::1;::::0;;;::::1;4862:202;5078:33;::::0;;11029:25:16;;;11085:2;11070:18;;11063:34;;;5089:10:15::1;::::0;5078:33:::1;::::0;11002:18:16;5078:33:15::1;;;;;;;5123:7;5136:6;-1:-1:-1::0;;;;;5136:11:15::1;5155:4;5136:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5122:42;;;5182:2;5174:28;;;::::0;-1:-1:-1;;;5174:28:15;;11520:2:16;5174:28:15::1;::::0;::::1;11502:21:16::0;11559:2;11539:18;;;11532:30;-1:-1:-1;;;11578:18:16;;;11571:43;11631:18;;5174:28:15::1;11318:337:16::0;5174:28:15::1;5212:14;5229:16;5241:4:::0;5229:9:::1;:16;:::i;:::-;5212:33:::0;-1:-1:-1;5259:10:15;;5255:138:::1;;5298:43;::::0;5286:6:::1;::::0;5306:10:::1;::::0;5330:6;;5286;5298:43;5286:6;5298:43;5330:6;5306:10;5298:43:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5285:56;;;5363:1;5355:27;;;::::0;-1:-1:-1;;;5355:27:15;;11862:2:16;5355:27:15::1;::::0;::::1;11844:21:16::0;11901:2;11881:18;;;11874:30;-1:-1:-1;;;11920:18:16;;;11913:43;11973:18;;5355:27:15::1;11660:337:16::0;5355:27:15::1;5271:122;5255:138;4299:1100;;;;4242:1157:::0;:::o;2446:74::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1861:208:1:-;1924:7;-1:-1:-1;;;;;1947:19:1;;1943:87;;1989:30;;-1:-1:-1;;;1989:30:1;;2016:1;1989:30;;;1701:51:16;1674:18;;1989:30:1;1555:203:16;1943:87:1;-1:-1:-1;;;;;;2046:16:1;;;;;:9;:16;;;;;;;1861:208::o;6222:704:15:-;6313:16;6331;6349:12;6363:13;6378:9;6389:11;6416:13;6432:21;6446:6;6432:13;:21::i;:::-;-1:-1:-1;;;;;6484:17:15;;6463:10;6484:17;;;:9;:17;;;;;;6416:37;;-1:-1:-1;6463:10:15;6484:17;;6476:25;;:57;;6532:1;6476:57;;;-1:-1:-1;;;;;6512:17:15;;;;;;:9;:17;;;;;;6504:25;;6512:17;;6504:5;:25;:::i;:::-;6463:70;;6543:10;6567;;1256:4;6556:21;;;;:::i;:::-;6543:34;;6603:2;6598;:7;:17;;6613:2;6598:17;;;6608:2;6598:17;-1:-1:-1;;;;;6656:17:15;;6625:10;6656:17;;;:9;:17;;;;;;6587:28;;-1:-1:-1;6625:10:15;6638:35;;6656:17;;1451:2;6638:35;:::i;:::-;6625:48;;6683:10;6707;;1301:4;6696:21;;;;:::i;:::-;6683:34;;6743:2;6738;:7;:17;;6753:2;6738:17;;;6748:2;6738:17;6727:28;;6772:12;6780:3;6772:7;:12::i;:::-;6805:25;;-1:-1:-1;;;6805:25:15;;-1:-1:-1;;;;;1719:32:16;;;6805:25:15;;;1701:51:16;6765:19:15;;-1:-1:-1;6833:1:15;;6805:7;:17;;;;1674:18:16;;6805:25:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:29;6794:40;;6869:7;6851:15;:25;6844:32;;1402:1;6895:5;:24;6886:33;;6406:520;;;;;6222:704;;;;;;;;:::o;2394:93:1:-;2441:13;2473:7;2466:14;;;;;:::i;5778:114:15:-;5827:7;1537:4;5853:1;:14;;:32;;1631:12;5853:32;;;1580:12;5846:39;5778:114;-1:-1:-1;;5778:114:15:o;3487:144:1:-;3572:52;735:10:7;3605:8:1;3615;3572:18;:52::i;6932:102:15:-;6978:7;7017:10;;7004;;:23;;;;:::i;:::-;6997:30;;6932:102;:::o;4630:233:1:-;4743:31;4756:4;4762:2;4766:7;4743:12;:31::i;:::-;4784:72;735:10:7;4832:4:1;4838:2;4842:7;4851:4;4784:33;:72::i;5972:148:15:-;6023:12;6064:1;6047:66;6072:3;6067:1;:8;6047:66;;6090:23;6111:1;6098:10;;:14;;;;:::i;6090:23::-;6082:31;;;;:::i;:::-;;-1:-1:-1;6077:3:15;;;:::i;:::-;;;6047:66;;;;5972:148;;;:::o;7209:126::-;7259:5;7276:17;7290:2;7276:13;:17::i;:::-;-1:-1:-1;7310:14:15;;;;:10;:14;;;;;;:18;;7327:1;;7310:14;;:18;:::i;7040:163::-;7100:13;7146:7;7155:31;7163:11;7171:2;7163:7;:11::i;:::-;7155:20;;:29;:31::i;:::-;7132:64;;;;;;;;;:::i;:::-;;;;;;;;;;;;;7125:71;;7040:163;;;:::o;6126:90::-;6173:7;6199:10;6207:1;6199:7;:10::i;3665:153:1:-;-1:-1:-1;;;;;3776:25:1;;;3753:4;3776:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;3665:153::o;5569:152:15:-;5629:7;5655:23;5671:6;5655:15;:23::i;:::-;:59;;1353:1;5655:59;;;1402:1;5648:66;5569:152;-1:-1:-1;;5569:152:15:o;15957:241:1:-;16020:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:1;;16082:88;;16128:31;;-1:-1:-1;;;16128:31:1;;;;;2868:25:16;;;2841:18;;16128:31:1;2722:177:16;14138:120:1;14218:33;14227:2;14231:7;14240:4;14246;14218:8;:33::i;8507:795::-;8593:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:1;;;;8704:18;;;8700:86;;8738:37;8755:4;8761;8767:7;8738:16;:37::i;:::-;-1:-1:-1;;;;;8830:18:1;;;8826:256;;8946:48;8963:1;8967:7;8984:1;8988:5;8946:8;:48::i;:::-;-1:-1:-1;;;;;9037:15:1;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9037:20:1;;;8826:256;-1:-1:-1;;;;;9096:16:1;;;9092:107;;-1:-1:-1;;;;;9156:13:1;;;;;;:9;:13;;;;;:18;;9173:1;9156:18;;;9092:107;9209:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9209:21:1;-1:-1:-1;;;;;9209:21:1;;;;;;;;;9246:27;;9209:16;;9246:27;;;;;;;9291:4;8507:795;-1:-1:-1;;;;8507:795:1:o;7500:470:15:-;7551:15;7571:7;;7569:9;;;;;:::i;:::-;;;;;-1:-1:-1;7667:9:15;;7621:41;;;7632:16;7621:41;;;14266:25:16;-1:-1:-1;;;;;14327:32:16;;14307:18;;;14300:60;;;;14376:18;;;14369:34;;;7569:9:15;;-1:-1:-1;7588:12:15;;14239:18:16;;7621:41:15;;;;;;;;;;;;7611:52;;;;;;7603:61;;:73;;;;:::i;:::-;7588:88;;7686:10;7711:7;7706:137;1685:1;7720:15;;;;7706:137;;;7767:8;7776:1;7767:11;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;7760:18;;:4;:18;7756:44;;;7789:1;7782:8;;7792:5;;7756:44;7821:8;7830:1;7821:11;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;7813:19;;;;;;;:::i;:::-;;-1:-1:-1;7737:3:15;;7706:137;;;;7870:1;7852:8;7861:4;7852:14;;;;;;;;;:::i;:::-;;;;;;;;;;;;:19;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;7894:1;7881:9;;:14;;;;;;;:::i;:::-;;;;-1:-1:-1;7927:8:15;;-1:-1:-1;7927:4:15;7934:1;7927:8;:::i;:::-;7905:19;;;;:10;:19;;;;;:30;;-1:-1:-1;;7905:30:15;;;;;;;;;;;;7945:18;7951:2;7905:19;7945:5;:18::i;7976:181::-;8038:15;8071:10;;8069:12;;;;;:::i;:::-;;;;;-1:-1:-1;8056:26:15;;1818:6;8056:26;:::i;:::-;8038:44;-1:-1:-1;8114:8:15;:4;8121:1;8114:8;:::i;:::-;8092:19;;;;:10;:19;;;;;:30;;-1:-1:-1;;8092:30:15;;;;;;;;;;;;8132:18;8138:2;8092:19;8132:5;:18::i;15311:411:1:-;-1:-1:-1;;;;;15418:19:1;;15414:90;;15460:33;;-1:-1:-1;;;15460:33:1;;15490:1;15460:33;;;1701:51:16;1674:18;;15460:33:1;1555:203:16;15414:90:1;-1:-1:-1;;;;;15517:22:1;;15513:91;;15562:31;;-1:-1:-1;;;15562:31:1;;-1:-1:-1;;;;;1719:32:16;;15562:31:1;;;1701:51:16;1674:18;;15562:31:1;1555:203:16;15513:91:1;-1:-1:-1;;;;;15613:25:1;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;15613:46:1;;;;;;;;;;15674:41;;540::16;;;15674::1;;513:18:16;15674:41:1;;;;;;;15311:411;;;:::o;994:926:5:-;-1:-1:-1;;;;;1174:14:5;;;:18;1170:744;;1212:67;;-1:-1:-1;;;1212:67:5;;-1:-1:-1;;;;;1212:36:5;;;;;:67;;1249:8;;1259:4;;1265:7;;1274:4;;1212:67;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1212:67:5;;;;;;;;-1:-1:-1;;1212:67:5;;;;;;;;;;;;:::i;:::-;;;1208:696;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1569:6;:13;1586:1;1569:18;1565:325;;1673:39;;-1:-1:-1;;;1673:39:5;;-1:-1:-1;;;;;1719:32:16;;1673:39:5;;;1701:51:16;1674:18;;1673:39:5;1555:203:16;1565:325:5;1842:6;1836:13;1829:4;1821:6;1817:17;1810:40;1208:696;-1:-1:-1;;;;;;1326:51:5;;-1:-1:-1;;;1326:51:5;1322:182;;1446:39;;-1:-1:-1;;;1446:39:5;;-1:-1:-1;;;;;1719:32:16;;1446:39:5;;;1701:51:16;1674:18;;1446:39:5;1555:203:16;1251:634:9;1307:13;1356:14;1373:17;1384:5;1373:10;:17::i;:::-;1393:1;1373:21;1356:38;;1408:20;1442:6;1431:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1431:18:9;-1:-1:-1;1408:41:9;-1:-1:-1;1538:30:9;;;1554:4;1538:30;1595:247;-1:-1:-1;;1626:5:9;-1:-1:-1;;;1725:2:9;1714:14;;1709:32;1626:5;1696:46;1786:2;1777:11;;;-1:-1:-1;1806:21:9;1595:247;1806:21;-1:-1:-1;1862:6:9;1251:634;-1:-1:-1;;;1251:634:9:o;14440:662:1:-;14600:9;:31;;;-1:-1:-1;;;;;;14613:18:1;;;;14600:31;14596:460;;;14647:13;14663:22;14677:7;14663:13;:22::i;:::-;14647:38;-1:-1:-1;;;;;;14813:18:1;;;;;;:35;;;14844:4;-1:-1:-1;;;;;14835:13:1;:5;-1:-1:-1;;;;;14835:13:1;;;14813:35;:69;;;;;14853:29;14870:5;14877:4;14853:16;:29::i;:::-;14852:30;14813:69;14809:142;;;14909:27;;-1:-1:-1;;;14909:27:1;;-1:-1:-1;;;;;1719:32:16;;14909:27:1;;;1701:51:16;1674:18;;14909:27:1;1555:203:16;14809:142:1;14969:9;14965:81;;;15023:7;15019:2;-1:-1:-1;;;;;15003:28:1;15012:5;-1:-1:-1;;;;;15003:28:1;;;;;;;;;;;14965:81;14633:423;14596:460;-1:-1:-1;;15066:24:1;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15066:29:1;-1:-1:-1;;;;;15066:29:1;;;;;;;;;;14440:662::o;6751:368::-;6863:38;6877:5;6884:7;6893;6863:13;:38::i;:::-;6858:255;;-1:-1:-1;;;;;6921:19:1;;6917:186;;6967:31;;-1:-1:-1;;;6967:31:1;;;;;2868:25:16;;;2841:18;;6967:31:1;2722:177:16;6917:186:1;7044:44;;-1:-1:-1;;;7044:44:1;;-1:-1:-1;;;;;16019:32:16;;7044:44:1;;;16001:51:16;16068:18;;;16061:34;;;15974:18;;7044:44:1;15827:274:16;9624:327:1;-1:-1:-1;;;;;9691:16:1;;9687:87;;9730:33;;-1:-1:-1;;;9730:33:1;;9760:1;9730:33;;;1701:51:16;1674:18;;9730:33:1;1555:203:16;9687:87:1;9783:21;9807:32;9815:2;9819:7;9836:1;9807:7;:32::i;:::-;9783:56;-1:-1:-1;;;;;;9853:27:1;;;9849:96;;9903:31;;-1:-1:-1;;;9903:31:1;;9931:1;9903:31;;;1701:51:16;1674:18;;9903:31:1;1555:203:16;29471:916:12;29524:7;;-1:-1:-1;;;29599:17:12;;29595:103;;-1:-1:-1;;;29636:17:12;;;-1:-1:-1;29681:2:12;29671:12;29595:103;29724:8;29715:5;:17;29711:103;;29761:8;29752:17;;;-1:-1:-1;29797:2:12;29787:12;29711:103;29840:8;29831:5;:17;29827:103;;29877:8;29868:17;;;-1:-1:-1;29913:2:12;29903:12;29827:103;29956:7;29947:5;:16;29943:100;;29992:7;29983:16;;;-1:-1:-1;30027:1:12;30017:11;29943:100;30069:7;30060:5;:16;30056:100;;30105:7;30096:16;;;-1:-1:-1;30140:1:12;30130:11;30056:100;30182:7;30173:5;:16;30169:100;;30218:7;30209:16;;;-1:-1:-1;30253:1:12;30243:11;30169:100;30295:7;30286:5;:16;30282:66;;30332:1;30322:11;30374:6;29471:916;-1:-1:-1;;29471:916:12:o;6047:272:1:-;6150:4;-1:-1:-1;;;;;6185:21:1;;;;;;:127;;;6232:7;-1:-1:-1;;;;;6223:16:1;:5;-1:-1:-1;;;;;6223:16:1;;:52;;;;6243:32;6260:5;6267:7;6243:16;:32::i;:::-;6223:88;;;-1:-1:-1;5679:7:1;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6279:32:1;;;5705:24;;6279:32;6223:88;6166:146;6047:272;-1:-1:-1;;;;6047:272:1:o;14:131:16:-;-1:-1:-1;;;;;;88:32:16;;78:43;;68:71;;135:1;132;125:12;68:71;14:131;:::o;150:245::-;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;:::-;384:5;150:245;-1:-1:-1;;;150:245:16:o;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:16;816:16;;809:27;592:250::o;847:282::-;900:3;938:5;932:12;965:6;960:3;953:19;981:76;1050:6;1043:4;1038:3;1034:14;1027:4;1020:5;1016:16;981:76;:::i;:::-;1111:2;1090:15;-1:-1:-1;;1086:29:16;1077:39;;;;1118:4;1073:50;;847:282;-1:-1:-1;;847:282:16:o;1134:231::-;1283:2;1272:9;1265:21;1246:4;1303:56;1355:2;1344:9;1340:18;1332:6;1303:56;:::i;1370:180::-;1429:6;1482:2;1470:9;1461:7;1457:23;1453:32;1450:52;;;1498:1;1495;1488:12;1450:52;-1:-1:-1;1521:23:16;;1370:180;-1:-1:-1;1370:180:16:o;1763:173::-;1831:20;;-1:-1:-1;;;;;1880:31:16;;1870:42;;1860:70;;1926:1;1923;1916:12;1860:70;1763:173;;;:::o;1941:254::-;2009:6;2017;2070:2;2058:9;2049:7;2045:23;2041:32;2038:52;;;2086:1;2083;2076:12;2038:52;2109:29;2128:9;2109:29;:::i;:::-;2099:39;2185:2;2170:18;;;;2157:32;;-1:-1:-1;;;1941:254:16:o;2389:328::-;2466:6;2474;2482;2535:2;2523:9;2514:7;2510:23;2506:32;2503:52;;;2551:1;2548;2541:12;2503:52;2574:29;2593:9;2574:29;:::i;:::-;2564:39;;2622:38;2656:2;2645:9;2641:18;2622:38;:::i;:::-;2612:48;;2707:2;2696:9;2692:18;2679:32;2669:42;;2389:328;;;;;:::o;2904:186::-;2963:6;3016:2;3004:9;2995:7;2991:23;2987:32;2984:52;;;3032:1;3029;3022:12;2984:52;3055:29;3074:9;3055:29;:::i;4309:347::-;4374:6;4382;4435:2;4423:9;4414:7;4410:23;4406:32;4403:52;;;4451:1;4448;4441:12;4403:52;4474:29;4493:9;4474:29;:::i;:::-;4464:39;;4553:2;4542:9;4538:18;4525:32;4600:5;4593:13;4586:21;4579:5;4576:32;4566:60;;4622:1;4619;4612:12;4566:60;4645:5;4635:15;;;4309:347;;;;;:::o;4661:127::-;4722:10;4717:3;4713:20;4710:1;4703:31;4753:4;4750:1;4743:15;4777:4;4774:1;4767:15;4793:1138;4888:6;4896;4904;4912;4965:3;4953:9;4944:7;4940:23;4936:33;4933:53;;;4982:1;4979;4972:12;4933:53;5005:29;5024:9;5005:29;:::i;:::-;4995:39;;5053:38;5087:2;5076:9;5072:18;5053:38;:::i;:::-;5043:48;;5138:2;5127:9;5123:18;5110:32;5100:42;;5193:2;5182:9;5178:18;5165:32;5216:18;5257:2;5249:6;5246:14;5243:34;;;5273:1;5270;5263:12;5243:34;5311:6;5300:9;5296:22;5286:32;;5356:7;5349:4;5345:2;5341:13;5337:27;5327:55;;5378:1;5375;5368:12;5327:55;5414:2;5401:16;5436:2;5432;5429:10;5426:36;;;5442:18;;:::i;:::-;5517:2;5511:9;5485:2;5571:13;;-1:-1:-1;;5567:22:16;;;5591:2;5563:31;5559:40;5547:53;;;5615:18;;;5635:22;;;5612:46;5609:72;;;5661:18;;:::i;:::-;5701:10;5697:2;5690:22;5736:2;5728:6;5721:18;5776:7;5771:2;5766;5762;5758:11;5754:20;5751:33;5748:53;;;5797:1;5794;5787:12;5748:53;5853:2;5848;5844;5840:11;5835:2;5827:6;5823:15;5810:46;5898:1;5893:2;5888;5880:6;5876:15;5872:24;5865:35;5919:6;5909:16;;;;;;;4793:1138;;;;;;;:::o;5936:260::-;6004:6;6012;6065:2;6053:9;6044:7;6040:23;6036:32;6033:52;;;6081:1;6078;6071:12;6033:52;6104:29;6123:9;6104:29;:::i;:::-;6094:39;;6152:38;6186:2;6175:9;6171:18;6152:38;:::i;:::-;6142:48;;5936:260;;;;;:::o;6201:380::-;6280:1;6276:12;;;;6323;;;6344:61;;6398:4;6390:6;6386:17;6376:27;;6344:61;6451:2;6443:6;6440:14;6420:18;6417:38;6414:161;;6497:10;6492:3;6488:20;6485:1;6478:31;6532:4;6529:1;6522:15;6560:4;6557:1;6550:15;6966:184;7036:6;7089:2;7077:9;7068:7;7064:23;7060:32;7057:52;;;7105:1;7102;7095:12;7057:52;-1:-1:-1;7128:16:16;;6966:184;-1:-1:-1;6966:184:16:o;7840:127::-;7901:10;7896:3;7892:20;7889:1;7882:31;7932:4;7929:1;7922:15;7956:4;7953:1;7946:15;7972:128;8039:9;;;8060:11;;;8057:37;;;8074:18;;:::i;8784:148::-;8872:4;8851:12;;;8865;;;8847:31;;8890:13;;8887:39;;;8906:18;;:::i;8937:125::-;9002:9;;;9023:10;;;9020:36;;;9036:18;;:::i;10682:168::-;10755:9;;;10786;;10803:15;;;10797:22;;10783:37;10773:71;;10824:18;;:::i;12002:135::-;12041:3;12062:17;;;12059:43;;12082:18;;:::i;:::-;-1:-1:-1;12129:1:16;12118:13;;12002:135::o;12142:151::-;12232:4;12225:12;;;12211;;;12207:31;;12250:14;;12247:40;;;12267:18;;:::i;12424:198::-;12466:3;12504:5;12498:12;12519:65;12577:6;12572:3;12565:4;12558:5;12554:16;12519:65;:::i;:::-;12600:16;;;;;12424:198;-1:-1:-1;;12424:198:16:o;12699:1360::-;12965:3;12994:1;13027:6;13021:13;13057:1;13077;13104:9;13101:1;13097:17;13087:27;;13164:1;13153:9;13149:17;13185:18;13175:61;;13229:4;13221:6;13217:17;13207:27;;13175:61;13255:2;13303;13295:6;13292:14;13272:18;13269:38;13266:161;;13349:10;13344:3;13340:20;13337:1;13330:31;13384:4;13381:1;13374:15;13412:4;13409:1;13402:15;13266:161;13443:18;13470:133;;;;13617:1;13612:320;;;;13436:496;;13470:133;-1:-1:-1;;13503:24:16;;13491:37;;13576:14;;13569:22;13557:35;;13548:45;;;-1:-1:-1;13470:133:16;;13612:320;12371:1;12364:14;;;12408:4;12395:18;;13707:1;13721:165;13735:6;13732:1;13729:13;13721:165;;;13813:14;;13800:11;;;13793:35;13856:16;;;;13750:10;;13721:165;;;13725:3;;13915:6;13910:3;13906:16;13899:23;;13436:496;;;;;;;13954:30;13980:3;13972:6;13954:30;:::i;:::-;-1:-1:-1;;;12672:20:16;;14051:1;14040:13;;;-1:-1:-1;;;;;12699:1360:16:o;14546:209::-;14578:1;14604;14594:132;;14648:10;14643:3;14639:20;14636:1;14629:31;14683:4;14680:1;14673:15;14711:4;14708:1;14701:15;14594:132;-1:-1:-1;14740:9:16;;14546:209::o;14760:127::-;14821:10;14816:3;14812:20;14809:1;14802:31;14852:4;14849:1;14842:15;14876:4;14873:1;14866:15;14892:171;14960:6;14999:10;;;14987;;;14983:27;;15022:12;;;15019:38;;;15037:18;;:::i;:::-;15019:38;14892:171;;;;:::o;15068:500::-;-1:-1:-1;;;;;15337:15:16;;;15319:34;;15389:15;;15384:2;15369:18;;15362:43;15436:2;15421:18;;15414:34;;;15484:3;15479:2;15464:18;;15457:31;;;15262:4;;15505:57;;15542:19;;15534:6;15505:57;:::i;:::-;15497:65;15068:500;-1:-1:-1;;;;;;15068:500:16:o;15573:249::-;15642:6;15695:2;15683:9;15674:7;15670:23;15666:32;15663:52;;;15711:1;15708;15701:12;15663:52;15743:9;15737:16;15762:30;15786:5;15762:30;:::i","linkReferences":{},"immutableReferences":{"7403":[{"start":2128,"length":32},{"start":3019,"length":32},{"start":3782,"length":32},{"start":5332,"length":32}],"7406":[{"start":1514,"length":32},{"start":2761,"length":32}],"7408":[{"start":1363,"length":32},{"start":4628,"length":32}],"7410":[{"start":986,"length":32}],"7412":[{"start":2210,"length":32},{"start":2906,"length":32},{"start":3669,"length":32},{"start":5442,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"agentId()","signatureHash4":"0xe84f43b7","signatureHash32":"0xe84f43b70829bd5d3c699eaeb40a3ba90f2f783a66edda95e93ef4009af84bb9"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"beastOf(uint256)","signatureHash4":"0xc3434429","signatureHash32":"0xc3434429f7ec0c1a5b5763edbdcb5e484ecdcace0ce5a24adfb60d3386b534f0"},{"signature":"BEAST_TYPES()","signatureHash4":"0xd2aba633","signatureHash32":"0xd2aba6331ce043a6a5abe7f484f8ac6437742767a24a2995757b8ffef995b802"},{"signature":"costWei(uint256)","signatureHash4":"0xb98510f9","signatureHash32":"0xb98510f9db7689fa5ee8ab945327f6498b624e900ba590c6ef8a8bbce1bd321f"},{"signature":"EPIC_AT()","signatureHash4":"0xdbc8b747","signatureHash32":"0xdbc8b7476a2c57a4a54db13407c46d61d66723125c0317d1fe29115589ef95cb"},{"signature":"epicMinted()","signatureHash4":"0x2fe66134","signatureHash32":"0x2fe661347dbc93399d38897d18985f322c8b7492891d7661ddb6f5b011a788a2"},{"signature":"EPIC_YINGLONG()","signatureHash4":"0xddfbae0d","signatureHash32":"0xddfbae0d879352b3084c07ac630be21defaf10e6116fb6ab9718429b6a804b86"},{"signature":"EPIC_ZHULONG()","signatureHash4":"0x0f39f9b9","signatureHash32":"0x0f39f9b9c79997a23b44efcba312a7bfc5febd2260f76fa64c404f2be02e3f41"},{"signature":"freeAllowance(address)","signatureHash4":"0xec6cf70c","signatureHash32":"0xec6cf70c8ace34cb5f3bcf9bcb866f78da8eacaf6aa7d0028afdfcbd1ee07eb7"},{"signature":"FREE_CAP()","signatureHash4":"0x4dbd691f","signatureHash32":"0x4dbd691fe61ca92b2700c917010d9403ca222f8f1734466893ef5f7c096cc239"},{"signature":"freeCount(address)","signatureHash4":"0x958c8848","signatureHash32":"0x958c884895a2abd1c46d227b61c334435821713e31721b9cda08a6eae74466d8"},{"signature":"freeMint()","signatureHash4":"0x5b70ea9f","signatureHash32":"0x5b70ea9fc6a30783be32c8c76d32dff0f3c052932b7deb1a16a6f56b4cf1672e"},{"signature":"freeMinted()","signatureHash4":"0xd10a1a2b","signatureHash32":"0xd10a1a2b5fc9278773c39046bbd52b75688d31907eb1dc45c1b2ce50f241c12f"},{"signature":"FREE_PER_HOLDER()","signatureHash4":"0xac6a96b1","signatureHash32":"0xac6a96b1a44cfc15dc03059b65298dbbaf37a94d68156935d8a1f23c02ee5394"},{"signature":"FREE_PER_WALLET()","signatureHash4":"0xcd90e5af","signatureHash32":"0xcd90e5af7c66183314b1f787317384e163b5fd5f3761c1a6fa675d75d5f9e35e"},{"signature":"getApproved(uint256)","signatureHash4":"0x081812fc","signatureHash32":"0x081812fc55e34fdc7cf5d8b5cf4e3621fa6423fde952ec6ab24afdc0d85c0b2e"},{"signature":"isApprovedForAll(address,address)","signatureHash4":"0xe985e9c5","signatureHash32":"0xe985e9c5c6636c6879256001057b28ccac7718ef0ac56553ff9b926452cab8a3"},{"signature":"isSeason2Holder(address)","signatureHash4":"0x3e6c7e75","signatureHash32":"0x3e6c7e75796b464b5ababdf96e55660c442a01e306ee0cd3e618e335a74aad04"},{"signature":"kindLeft(uint256)","signatureHash4":"0x6ee5c9fb","signatureHash32":"0x6ee5c9fbfa4b3c1742cf54949af94066975b65557ef9549f7e65a76e11b5aabe"},{"signature":"mint()","signatureHash4":"0x1249c58b","signatureHash32":"0x1249c58b84ff771f36a0d1d2bf0b42e48832b1567c4213f113d3990903cea57d"},{"signature":"mintEnd()","signatureHash4":"0xea2b4ab2","signatureHash32":"0xea2b4ab23e09f89ff1d0c8b4139ff4162a55663aff9eb64cb6e9aaf751964d8d"},{"signature":"mintPriceWei()","signatureHash4":"0xcb2c9722","signatureHash32":"0xcb2c9722ca6e322037cca43276c0021a62373b77afb81f02eb41a6d4487a3440"},{"signature":"mintStart()","signatureHash4":"0x255e4685","signatureHash32":"0x255e468503ca9dbf94d864eec57aef52beb4b7152bf54b615325a09db70000e8"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"ownerOf(uint256)","signatureHash4":"0x6352211e","signatureHash32":"0x6352211e6566aa027e75ac9dbf2423197fbd9b82b9d981a3ab367d355866aa1c"},{"signature":"PAID_CAP()","signatureHash4":"0xfb3fecd3","signatureHash32":"0xfb3fecd3be523b6d8f8ec9f4de1f7cac87156689231317b5c84e4208b6aa754e"},{"signature":"paidCount(address)","signatureHash4":"0x3e8f8723","signatureHash32":"0x3e8f87235f094cf3ff7a8d85687fd276ddc7530053b07766078a8b279dd00553"},{"signature":"paidMinted()","signatureHash4":"0x2806b8fb","signatureHash32":"0x2806b8fbb83809bce38f9e2a430acda98d4f66ce943ff9bc85da57f27db32797"},{"signature":"paidMint(uint256)","signatureHash4":"0x65cde733","signatureHash32":"0x65cde733d6375fe98a912f476f55e7dfb8518675a62a3a236f83f53e3edadbcc"},{"signature":"PAID_PER_WALLET()","signatureHash4":"0xdb9915b3","signatureHash32":"0xdb9915b3beb59c5ab20789dcbcc841287071dc06dccfdb7fe15d134b69c9a7b2"},{"signature":"payout()","signatureHash4":"0x63bd1d4a","signatureHash32":"0x63bd1d4a88bedfb7160db00a11fe1bffc8c945fca05210a721e82aed26239413"},{"signature":"points(address)","signatureHash4":"0x358b8166","signatureHash32":"0x358b816638cd7802503d984fe0bcfd905fc77e58cedec9470d653bdceb71a3a0"},{"signature":"PRICE1()","signatureHash4":"0x27595a80","signatureHash32":"0x27595a80cbaf9da7d627b28880315c0b81a977b03d62dfb4b52c689501f15175"},{"signature":"PRICE2()","signatureHash4":"0xa1542bd2","signatureHash32":"0xa1542bd2fc00d3abbf16b56da7489f2c0db55a607ef9fdccfa09ce4d762ab699"},{"signature":"priceAt(uint256)","signatureHash4":"0x9dab2054","signatureHash32":"0x9dab2054c606f1ec1e7dd243e947bf76b3de2a7c5f499c947569b5f9d7f900fc"},{"signature":"quote(address,uint256)","signatureHash4":"0x8f79306e","signatureHash32":"0x8f79306e7dbee0a4dbf3bdc8d8107cf7e7a1ed4e2b28094d37fac66d86ae910f"},{"signature":"safeTransferFrom(address,address,uint256)","signatureHash4":"0x42842e0e","signatureHash32":"0x42842e0eb38857a7775b4e7364b2775df7325074d088e7fb39590cd6281184ed"},{"signature":"safeTransferFrom(address,address,uint256,bytes)","signatureHash4":"0xb88d4fde","signatureHash32":"0xb88d4fde60196325a28bb7f99a2582e0b46de55b18761e960c14ad7a32099465"},{"signature":"season2()","signatureHash4":"0x82a8de91","signatureHash32":"0x82a8de91fd1770f9dd9bb5cb2bf579ee4e3b789288598c964760412c462b0489"},{"signature":"setApprovalForAll(address,bool)","signatureHash4":"0xa22cb465","signatureHash32":"0xa22cb4651ab9570f89bb516380c40ce76762284fb1f21337ceaf6adab99e7d4a"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"TIER1_END()","signatureHash4":"0xaa4ac63f","signatureHash32":"0xaa4ac63faaa4a47c9ec6c3d700d85e8d13c71adf0887fcc859b91a86cd522aa0"},{"signature":"tokenURI(uint256)","signatureHash4":"0xc87b56dd","signatureHash32":"0xc87b56dda752230262935940d907f047a9f86bb5ee6aa33511fc86db33fea6cc"},{"signature":"totalMinted()","signatureHash4":"0xa2309ff8","signatureHash32":"0xa2309ff8a1f86a4fb15fe22cc66ca2240889c22973a8705ca226daf66b420ca7"},{"signature":"totalPoints()","signatureHash4":"0x567142be","signatureHash32":"0x567142beb0ff36bfdf3fff4a56cb64451941b244efd2ac6cc86bfe74e90cbe56"},{"signature":"totalRevenueWei()","signatureHash4":"0xa0b93856","signatureHash32":"0xa0b9385620840b7adca274fd1ce3cd19d3530236d6d8ec4bfa46f03558c14cfe"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"ApprovalForAll(address,address,bool)","signatureHash4":"0x17307eab","signatureHash32":"0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31"},{"signature":"EpicRewarded(address)","signatureHash4":"0xcace12c4","signatureHash32":"0xcace12c4f853c8b402ff58c2fd1a4a066f2e98b46d8fd47bf4a6320102aed329"},{"signature":"FreeMinted(address,uint256,bool)","signatureHash4":"0x73bb3336","signatureHash32":"0x73bb33365059ea6ca29660beef1bc6ff9f16241f6e85a5d3170dcc45b5644f65"},{"signature":"PaidMinted(address,uint256,uint256)","signatureHash4":"0x12d09a8d","signatureHash32":"0x12d09a8dfc6b5d28033faed5ee2c0555b48cad9ce6b134630c05b50ffe7429c0"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[{"signature":"ERC721IncorrectOwner(address,uint256,address)","signatureHash4":"0x64283d7b","signatureHash32":"0x64283d7b313c8117c125f736876fa2b4e90ea3831a4716dfdb87d2f540e26289"},{"signature":"ERC721InsufficientApproval(address,uint256)","signatureHash4":"0x177e802f","signatureHash32":"0x177e802f6f313bc89797ecace66d6d29ab4719cbaaacbb87367264048b1eb861"},{"signature":"ERC721InvalidApprover(address)","signatureHash4":"0xa9fbf51f","signatureHash32":"0xa9fbf51f86b8e03595d59dc726bb10c329bb24f62589be276d8dd193ca0b69ea"},{"signature":"ERC721InvalidOperator(address)","signatureHash4":"0x5b08ba18","signatureHash32":"0x5b08ba185e8f577075361f3a3555a6580a227ce22734dcc979c1aeadf894658b"},{"signature":"ERC721InvalidOwner(address)","signatureHash4":"0x89c62b64","signatureHash32":"0x89c62b6479af2e623826dcc39c5133061d35b66d72de92833401dd2fd6567480"},{"signature":"ERC721InvalidReceiver(address)","signatureHash4":"0x64a0ae92","signatureHash32":"0x64a0ae9278f805eaf991dcd18ca78756d280b7508b764ef1b255c55845c11df9"},{"signature":"ERC721InvalidSender(address)","signatureHash4":"0x73c6ac6e","signatureHash32":"0x73c6ac6e10798e95d99e1f130d923eb40193ecb8d094ec3dce93292564eb3b17"},{"signature":"ERC721NonexistentToken(uint256)","signatureHash4":"0x7e273289","signatureHash32":"0x7e273289a3a9ef6670f06df7dca227856fc925e956db96980692764a8bc734d7"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0x2CCb3fA957E69AbD46A6651CC1444EF2Ea9bd591"}