{"matchId":"29982470","creationMatch":null,"runtimeMatch":"exact_match","verifiedAt":"2026-05-26T18:18:06Z","creationBytecode":{"onchainBytecode":null,"recompiledBytecode":"0x60e060409080825234620003665762002314803803809162000022828562000630565b8339810190606081830312620003665780516001600160401b0392908381116200036657816200005491840162000654565b602091828401519085821162000366576200007787916200007f93870162000654565b9401620006c8565b8151948086116200053b5760038054966001948589811c9916801562000625575b878a101462000611578190601f998a8111620005be575b5087908a83116001146200055b575f926200054f575b50505f1982841b1c191690851b1781555b85519182116200053b5760049586548581811c9116801562000530575b878210146200051d5790818985949311620004c8575b50869089841160011462000461575f9362000455575b505082851b925f19911b1c19161784555b6200014333620006dd565b610fa06006556101f46007556105dc600855610e10600c5560c8600e556001600160a01b038181169590919086156200041457506002546b204fce5e3e250261100000009081810180911162000401575f7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef87620001dc95948b946002558484528382528c84208181540190558c51908152a3620006dd565b46606103620003cb5773c5a25d89470e873e8f37ea2b2e8d2e66181ddef860c05273d99d1c33f9fc3444f8101754abc46c52416550d16080525b8383826080511688519687809263c45a015560e01b82525afa948515620003c1575f956200037c575b5090604484925f8360c05116938a5198899586946364e329cb60e11b865230908601526024850152165af1801562000372575f9062000324575b5f80516020620022f4833981519152935060a052835f52600b8252845f208160ff198254161790558451908152a251611bce90816200072682396080518181816103b301526113e9015260a05181818161043b01528181610853015281816110bd015281816110ea01528181611192015281816111b8015281816111ff015281816112dd01528181611354015281816113980152818161147b015261199b015260c051816105ac0152f35b508183813d83116200036a575b6200033d818362000630565b810103126200036657620003605f80516020620022f483398151915293620006c8565b62000279565b5f80fd5b503d62000331565b85513d5f823e3d90fd5b919094508382813d8311620003b9575b62000398818362000630565b8101031262000366576044620003af8593620006c8565b959192506200023f565b503d6200038c565b87513d5f823e3d90fd5b7355d398326f99059ff775485246999027b319795560c0527310ed43c718714eb63d5aa57b78b54704e256024e60805262000216565b601187634e487b7160e01b5f525260245ffd5b85606491868a519262461bcd60e51b845283015260248201527f45524332303a206d696e7420746f20746865207a65726f2061646472657373006044820152fd5b015191505f8062000127565b9190869450601f19841692895f52885f20935f5b8a828210620004b1575050851162000497575b50505050811b01845562000138565b01519060f8845f19921b161c191690555f80808062000488565b8385015187558a9890960195938401930162000475565b90919250875f52865f208980860160051c82019289871062000513575b91889187969594930160051c01915b8281106200050457505062000111565b5f8155869550889101620004f4565b92508192620004e5565b602288634e487b7160e01b5f525260245ffd5b90607f1690620000fb565b634e487b7160e01b5f52604160045260245ffd5b015190505f80620000cd565b90879350601f19831691855f52895f20925f5b8b828210620005a757505084116200058f575b505050811b018155620000de565b01515f1983861b60f8161c191690555f808062000581565b8385015186558b979095019493840193016200056e565b909150835f52875f208a80850160051c8201928a861062000607575b918991869594930160051c01915b828110620005f8575050620000b7565b5f8155859450899101620005e8565b92508192620005da565b634e487b7160e01b5f52602260045260245ffd5b98607f1698620000a0565b601f909101601f19168101906001600160401b038211908210176200053b57604052565b919080601f84011215620003665782516001600160401b0381116200053b57602090604051926200068f83601f19601f850116018562000630565b81845282828701011162000366575f5b818110620006b45750825f9394955001015290565b85810183015184820184015282016200069f565b51906001600160a01b03821682036200036657565b600580546001600160a01b039283166001600160a01b0319821681179092559091167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a356fe60806040818152600480361015610014575f80fd5b5f925f3560e01c90816303807ee514610beb5750806306fdde0314610af6578063095ea7b314610acd578063172979e414610a9157806318160ddd14610a7357806323626df714610a1d57806323b872dd14610955578063313ce5671461093a57806339509351146108ee57806341a2ac70146108ce5780634eb9b26d1461082a57806356dc73191461080b57806366345da4146107e257806370a08231146107ab578063715018a61461074e5780637a5185b71461072c5780637eddab541461070a5780638da5cb5b146106e157806395d89b41146105db5780639ab4a44514610597578063a01c34831461057a578063a457c2d7146104d3578063a9059cbb146104a2578063b340364f1461046a578063b7352a1914610426578063b7bac57914610404578063bb1570da146103e2578063c31c9c071461039e578063ceb807a714610375578063d83d4143146102f3578063da0a4ef2146102d4578063dd62ed3e14610287578063e3067449146102645763f2fde38b14610196575f80fd5b34610260576020366003190112610260576101af610c4c565b906101b8611018565b6001600160a01b0391821692831561020e575050600554826bffffffffffffffffffffffff60a01b821617600555167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a380f35b906020608492519162461bcd60e51b8352820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152fd5b8280fd5b505034610283578160031936011261028357602090600d549051908152f35b5080fd5b5050346102835780600319360112610283576020916102a4610c4c565b826102ad610c62565b6001600160a01b03928316845260018652922091165f908152908352819020549051908152f35b5050346102835781600319360112610283576020906007549051908152f35b50503461028357806003193601126102835761030d610c4c565b60243590811515809203610371577feafc0d355d7b7a7d30b5ab1c2a43600626ad786d167f6bc97823eb50fa1df74891602091610348611018565b6001600160a01b0316808652600b8352848620805460ff191660ff84161790559351908152a280f35b8380fd5b50503461028357816003193601126102835760095490516001600160a01b039091168152602090f35b505034610283578160031936011261028357517f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03168152602090f35b838234610283576020366003190112610283576103fd611018565b35600e5580f35b8382346102835760203660031901126102835761041f611018565b35600c5580f35b505034610283578160031936011261028357517f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03168152602090f35b5050346102835760203660031901126102835760609061049061048b610c4c565b610d16565b91929081519384526020840152820152f35b5050346102835780600319360112610283576020906104cc6104c2610c4c565b6024359033611070565b5160018152f35b5082346105775782600319360112610577576104ed610c4c565b91836024359233815260016020522060018060a01b0384165f52602052835f205490828210610526576020856104cc8585038733610f1a565b608490602086519162461bcd60e51b8352820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b6064820152fd5b80fd5b5050346102835781600319360112610283576020905161dead8152f35b505034610283578160031936011261028357517f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03168152602090f35b5091903461028357816003193601126102835780519180938054916001908360011c92600185169485156106d7575b60209586861081146106c4578589529081156106a05750600114610648575b610644878761063a828c0383610ca0565b5191829182610c05565b0390f35b81529295507f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b5b82841061068d57505050826106449461063a92820101945f80610629565b805486850188015292860192810161066f565b60ff19168887015250505050151560051b830101925061063a826106445f80610629565b634e487b7160e01b845260228352602484fd5b93607f169361060a565b50503461028357816003193601126102835760055490516001600160a01b039091168152602090f35b83823461028357602036600319011261028357610725611018565b3560065580f35b83823461028357602036600319011261028357610747611018565b3560075580f35b8334610577578060031936011261057757610767611018565b600580546001600160a01b031981169091555f906001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a380f35b5050346102835760203660031901126102835760209181906001600160a01b036107d3610c4c565b16815280845220549051908152f35b505034610283578160031936011261028357600a5490516001600160a01b039091168152602090f35b505034610283578160031936011261028357602090600c549051908152f35b5090346108ca5760203660031901126108ca57610845611018565b6005546001600160a01b03907f0000000000000000000000000000000000000000000000000000000000000000906108829085359084168361187f565b1691823b156108ca57815160016209351760e01b03198152925f918491829084905af19081156108c157506108b5575080f35b6108bf9150610c78565b005b513d5f823e3d90fd5b5f80fd5b50346108ca5760203660031901126108ca576108e8611018565b35600855005b82346108ca57806003193601126108ca576020906104cc61090d610c4c565b335f5260018452825f2060018060a01b0382165f528452610933602435845f2054610cc2565b9033610f1a565b82346108ca575f3660031901126108ca576020905160128152f35b50346108ca5760603660031901126108ca5761096f610c4c565b610977610c62565b906044359260018060a01b0382165f526001602052845f20335f52602052845f2054905f1982036109b1575b6020866104cc878787611070565b8482106109da57509183916109cf602096956104cc95033383610f1a565b9193948193506109a3565b606490602087519162461bcd60e51b8352820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152fd5b82346108ca573660031901126108ca57610a35610c4c565b610a3d610c62565b610a45611018565b600980546001600160a01b039384166001600160a01b031991821617909155600a8054929093169116179055005b82346108ca575f3660031901126108ca576020906002549051908152f35b82346108ca5760203660031901126108ca576020906001600160a01b03610ab6610c4c565b165f52600b825260ff815f20541690519015158152f35b82346108ca57806003193601126108ca576020906104cc610aec610c4c565b6024359033610f1a565b5090346108ca575f3660031901126108ca578051905f9260035460018160011c91600181168015610be1575b6020948585108214610bce5750838752908115610bae5750600114610b54575b50505061063a82610644940383610ca0565b60035f9081529295507fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b5b828410610b9b57505050826106449461063a9282010194610b42565b8054868501880152928601928101610b7f565b60ff1916868501525050151560051b830101925061063a82610644610b42565b602290634e487b7160e01b5f525260245ffd5b92607f1692610b22565b346108ca575f3660031901126108ca57602090600e548152f35b602080825282518183018190529093925f5b828110610c3857505060409293505f838284010152601f8019910116010190565b818101860151848201604001528501610c17565b600435906001600160a01b03821682036108ca57565b602435906001600160a01b03821682036108ca57565b67ffffffffffffffff8111610c8c57604052565b634e487b7160e01b5f52604160045260245ffd5b90601f8019910116810190811067ffffffffffffffff821117610c8c57604052565b91908201809211610ccf57565b634e487b7160e01b5f52601160045260245ffd5b51906001600160701b03821682036108ca57565b908160209103126108ca57516001600160a01b03811681036108ca5790565b60408051630240bc6b60e21b81526001600160a01b0393928416929190606081600481875afa908115610f10575f905f92610eb9575b506001600160701b03809116911694825190630dfe168160e01b80835260209283816004818b5afa908115610eaf575f91610e92575b5082163003610e545750835163d21220a760e01b815282816004818a5afa908115610e4a575f91610e1d575b505b169130831015610e1557819096955b60248551809581936370a0823160e01b835260048301525afa9283156108c157505f92610deb57505090565b90809250813d8311610e0e575b610e028183610ca0565b810103126108ca575190565b503d610df8565b948190610dbf565b610e3d9150833d8511610e43575b610e358183610ca0565b810190610cf7565b5f610dae565b503d610e2b565b85513d5f823e3d90fd5b845190815282816004818a5afa908115610e4a575f91610e75575b50610db0565b610e8c9150833d8511610e4357610e358183610ca0565b5f610e6f565b610ea99150843d8611610e4357610e358183610ca0565b5f610d82565b86513d5f823e3d90fd5b9150506060813d606011610f08575b81610ed560609383610ca0565b810103126108ca57610ee681610ce3565b82610ef360208401610ce3565b92015163ffffffff8116036108ca575f610d4c565b3d9150610ec8565b82513d5f823e3d90fd5b6001600160a01b03908116918215610fc75716918215610f775760207f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591835f526001825260405f20855f5282528060405f2055604051908152a3565b60405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608490fd5b60405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608490fd5b6005546001600160a01b0316330361102c57565b606460405162461bcd60e51b815260206004820152602060248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152fd5b60018060a01b0381165f525f6020528260405f20541061172e576001600160a01b0381165f908152600b602052604090205460ff168015611712575b611707576001600160a01b038181167f0000000000000000000000000000000000000000000000000000000000000000909116146116c2575f61110e7f0000000000000000000000000000000000000000000000000000000000000000610d16565b915f811515806116b9575b6116a0575b6111289082610cc2565b83101561137d575b505050600f5460ff81161580611346575b8061133e575b80611326575b611305575b5015806112cf575b61116b5790611169929161187f565b565b90612710926111b68461118060065484611945565b600954919004906001600160a01b03167f000000000000000000000000000000000000000000000000000000000000000061187f565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03163b156108ca5760405160016209351760e01b03198152905f82600481837f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03165af180156112c457611169956112af936112aa926112b5575b507fb01e5788449b89e730c08c951b01e9d8a7b29b698685b6a0c13096c472e9ac1d6020604051858152a18061127860085485611945565b049061128660075485611945565b0492611292848861176a565b600a546112aa9083906001600160a01b03168961187f565b611a4a565b9161187f565b6112be90610c78565b5f611240565b6040513d5f823e3d90fd5b506001600160a01b038281167f00000000000000000000000000000000000000000000000000000000000000009091161461115a565b60ff19908116600117600f55611319611976565b600f5416600f555f611152565b506009546001600160a01b038481169116141561114d565b508115611147565b506001600160a01b038381167f00000000000000000000000000000000000000000000000000000000000000009091161415611141565b6040516318160ddd60e01b81525f94509290916020846004817f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03165afa9384156112c4575f9461166c575b5060405163c45a015560e01b81528492906020816004817f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03165afa9081156112c4576004916020915f9161164f575b50604051622fcfcb60e31b815292839182906001600160a01b03165afa9081156112c4575f91611630575b50604051637464fc3d60e01b8152956001600160a01b03918216151591602090889060049082907f0000000000000000000000000000000000000000000000000000000000000000165afa9182156112c4578b975f936115f6575b5086929190806115ed575b611544575b50506114c891611a4a565b928261150a57505050806114e2575b50505b5f8080611130565b6114f69250906114f191611945565b611a57565b6103e7198101908111610ccf57835f6114d7565b82955061152f9450611523611523936115289395611945565b611958565b9387611945565b8082101561153d57506114da565b90506114da565b90916115566114f18661155c93611945565b92611a57565b9081831161156d575b8692506114bd565b909291965061158561157f8489611a4a565b82611945565b9687600381020460031488151715610ccf5780600581020460051481151715610ccf578b9760036115bd899660056115c49502610cc2565b9102611958565b90816115d3575b829350611565565b6114c893929550906115e491610cc2565b9390915f6115cb565b508115156114b8565b92509096506020823d602011611628575b8161161460209383610ca0565b810103126108ca5790518a969091866114ad565b3d9150611607565b611649915060203d602011610e4357610e358183610ca0565b5f611452565b6116669150823d8411610e4357610e358183610ca0565b5f611427565b9093506020813d602011611698575b8161168860209383610ca0565b810103126108ca5751925f6113d0565b3d915061167b565b506111286116b283611523848b611945565b905061111e565b50821515611119565b60405162461bcd60e51b815260206004820152601760248201527f63616e6e6f7420627579206f722072656d6f7665206c700000000000000000006044820152606490fd5b90611169929161187f565b506001600160a01b0382165f908152604090205460ff166110ac565b60405162461bcd60e51b815260206004820152601460248201527310985b185b98d9481a5b9cdd59999a58da595b9d60621b6044820152606490fd5b6001600160a01b0316801561182c57805f525f60205260405f20548281106117d8578290825f525f6020520360405f20557fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602061dead93845f5260405f20818154019055604051908152a3565b60405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b6064820152608490fd5b60405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b6064820152608490fd5b6001600160a01b0390811691821561182c57169182156118f457815f525f60205260405f20548181106117d857817fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92602092855f525f84520360405f2055845f5260405f20818154019055604051908152a3565b60405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b6064820152608490fd5b81810292918115918404141715610ccf57565b8115611962570490565b634e487b7160e01b5f52601260045260245ffd5b600c54600d54908115159081611a37575b50611a34576119eb620151806127106119e37f0000000000000000000000000000000000000000000000000000000000000000946119de6119d46119ca88610d16565b5093905042611a4a565b91600e5490611945565b611945565b04048261176a565b6001600160a01b0316803b156108ca575f809160046040518094819363fff6cae960e01b83525af180156112c457611a25575b5042600d55565b611a2e90610c78565b5f611a1e565b50565b611a42915082610cc2565b42105f611987565b91908203918211610ccf57565b8015611b9357611b21815f908360801c80611b87575b508060401c80611b7a575b508060201c80611b6d575b508060101c80611b60575b508060081c80611b53575b508060041c80611b46575b508060021c80611b39575b50600191828092811c611b32575b1c1b611ac98185611958565b01811c611ad68185611958565b01811c611ae38185611958565b01811c611af08185611958565b01811c611afd8185611958565b01811c611b0a8185611958565b01811c611b178185611958565b01901c8092611958565b80821015611b2d575090565b905090565b0181611abd565b600291509101905f611aaf565b600491509101905f611aa4565b600891509101905f611a99565b601091509101905f611a8e565b602091509101905f611a83565b604091509101905f611a78565b9150506080905f611a6d565b505f9056fea264697066735822122028a19f191e8dc50149a5f2e355ef1763e448942ba99716212ae19ed7aefb1c8564736f6c63430008160033eafc0d355d7b7a7d30b5ab1c2a43600626ad786d167f6bc97823eb50fa1df748","sourceMap":"2243:8010:6:-:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;2046:13:1;2243:8010:6;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;-1:-1:-1;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;2069:17:1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;955:12:0;734:10:4;955:12:0;:::i;:::-;2415:4:6;;2243:8010;2450:3;;2243:8010;2487:4;;2243:8010;2791:10;;2243:8010;2869:3;;2243:8010;-1:-1:-1;;;;;2243:8010:6;;;;;;;8603:21:1;;2243:8010:6;;;8731:22:1;2243:8010:6;3332:14;2243:8010;;;;;;;;;-1:-1:-1;8952:37:1;2243:8010:6;3376:8;2243:8010;;;;8731:22:1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;8952:37:1;3376:8:6;:::i;:::-;3400:13;3417:2;3400:19;3417:2;;3449:42;3435:56;;3554:42;3505:105;;3396:431;2243:8010;;;3892:10;2243:8010;;;;;;;;;;;3892:20;;;;;;;;;-1:-1:-1;3892:20:6;;;3396:431;2243:8010;;;;;-1:-1:-1;2243:8010:6;3965:11;2243:8010;;;;;;;;;;;;;3874:112;;3946:4;3874:112;;;2243:8010;;;;;;3874:112;;;;;;-1:-1:-1;3874:112:6;;;3396:431;-1:-1:-1;;;;;;;;;;;3863:123:6;;;;2243:8010;-1:-1:-1;2243:8010:6;6000:12;2243:8010;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;6042:33;2243:8010;;;;;;;3892:10;2243:8010;;;;;;;;;;3863:123;2243:8010;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3965:11;2243:8010;;;;;;3874:112;;;;;;;;;;;;;;;:::i;:::-;;;2243:8010;;;;;-1:-1:-1;;;;;;;;;;;2243:8010:6;;:::i;:::-;3874:112;;2243:8010;-1:-1:-1;2243:8010:6;;3874:112;;;;;;2243:8010;;;-1:-1:-1;2243:8010:6;;;;;3892:20;;;;;;;;;;;;;;;;;;:::i;:::-;;;2243:8010;;;;;;;;;:::i;:::-;3892:20;;;;;;;;;;;;2243:8010;;;-1:-1:-1;2243:8010:6;;;;;3396:431;3655:42;3641:56;;3760:42;3711:105;;3396:431;;2243:8010;;;;;;-1:-1:-1;2243:8010:6;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;2069:17:1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;:::o;2426:187:0:-;2518:6;2243:8010:6;;-1:-1:-1;;;;;2243:8010:6;;;-1:-1:-1;;;;;;2243:8010:6;;;;;;;;;;2566:40:0;-1:-1:-1;;2566:40:0;2426:187::o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122028a19f191e8dc50149a5f2e355ef1763e448942ba99716212ae19ed7aefb1c8564736f6c63430008160033","offset":8895}},"transformations":null,"transformationValues":null},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"2243:8010:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;:::i;:::-;1063:62:0;;;:::i;:::-;-1:-1:-1;;;;;2243:8010:6;;;;2162:22:0;;2243:8010:6;;;;2518:6:0;2243:8010:6;;;;;;;;2518:6:0;2243:8010:6;;2566:40:0;2243:8010:6;2566:40:0;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;2807:27;2243:8010;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2425:28;2243:8010;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;6042:33;1063:62:0;2243:8010:6;1063:62:0;;;:::i;:::-;-1:-1:-1;;;;;2243:8010:6;;;;6000:12;2243:8010;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;;;;;6042:33;2243:8010;;;;;;;;;;;;;;;;;;;;2632:33;2243:8010;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;2498:46;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4646:26;2243:8010;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4522:36;2243:8010;;;;;;;;;;;;;;;;;;2550:33;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3894:6:1;2243:8010:6;;:::i;:::-;;;734:10:4;;3894:6:1;:::i;:::-;2243:8010:6;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;734:10:4;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;6792:35:1;;;;2243:8010:6;;;;6928:34:1;2243:8010:6;;;;734:10:4;6928:34:1;:::i;2243:8010:6:-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;2339:42;2243:8010;;;;;;;;;;;;;;;;;;2589:36;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;-1:-1:-1;;;;2243:8010:6;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1273:6:0;2243:8010:6;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4756:22;2243:8010;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4858:18;2243:8010;;;;;;;;;;;;;;;;1063:62:0;;:::i;:::-;2518:6;2243:8010:6;;-1:-1:-1;;;;;;2243:8010:6;;;;;;;-1:-1:-1;;;;;2243:8010:6;2566:40:0;2243:8010:6;;2566:40:0;2243:8010:6;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2671:28;2243:8010;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;2757:44;2243:8010;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;1273:6;2243:8010:6;-1:-1:-1;;;;;2243:8010:6;6631:8;;6650:6;;2243:8010;;;;;6631:8;6650:6;:::i;:::-;2243:8010;6667:26;;;;;;2243:8010;;-1:-1:-1;;;;;;6667:26:6;;2243:8010;;;;;;;;;6667:26;;;;;;;;;;2243:8010;;;6667:26;;;;;:::i;:::-;2243:8010;6667:26;2243:8010;;;;;;;;6667:26;2243:8010;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4960:22;2243:8010;;;;;;;;;;;;;;;;;6021:38:1;2243:8010:6;;:::i;:::-;734:10:4;2243:8010:6;;;;;;;;;;;;;;;;;;;6021:38:1;2243:8010:6;;;;;;6021:38:1;:::i;:::-;734:10:4;;6021:38:1;:::i;2243:8010:6:-;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;3186:2:1;2243:8010:6;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;734:10:4;2243:8010:6;;;;;;;;11264:17:1;;;11244:37;;11240:243;;2243:8010:6;;5424:6:1;;;;;;:::i;11240:243::-;11305:26;;;2243:8010:6;;;;;;11432:25:1;2243:8010:6;;;5424:6:1;2243:8010:6;;734:10:4;11432:25:1;;:::i;:::-;11240:243;;;;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;:::i;:::-;;;:::i;:::-;1063:62:0;;:::i;:::-;4344:40:6;2243:8010;;-1:-1:-1;;;;;2243:8010:6;;;-1:-1:-1;;;;;;2243:8010:6;;;;;;;4394:30;2243:8010;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;3342:12:1;2243:8010:6;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;-1:-1:-1;;;;;2243:8010:6;;:::i;:::-;;;;2706:44;2243:8010;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4606:6:1;2243:8010:6;;:::i;:::-;;;734:10:4;;4606:6:1;:::i;2243:8010:6:-;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;;2244:5:1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2244:5:1;2243:8010:6;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;2840:32;2243:8010;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;:::o;:::-;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;:::o;:::-;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;:::o;9248:621::-;2243:8010;;;-1:-1:-1;;;9482:22:6;;-1:-1:-1;;;;;2243:8010:6;;;;;9248:621;2243:8010;9482:22;2243:8010;9482:22;2243:8010;;9482:22;;;;;;;;;;;;;9248:621;2243:8010;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;9536:17;;;;;;;9482:22;9536:17;;;;;;;;;9482:22;9536:17;;;9248:621;-1:-1:-1;2243:8010:6;;9565:4;9536:34;9565:4;;-1:-1:-1;2243:8010:6;;-1:-1:-1;;;9585:17:6;;;2243:8010;9482:22;2243:8010;9585:17;;;;;;;;9482:22;9585:17;;;9536:98;;;2243:8010;;9565:4;9649:26;;9565:4;;;9691:11;;9716:10;9645:158;;2243:8010;;;;;;;;;;9828:34;;9482:22;9828:34;;2243:8010;9828:34;;;;;;;;9482:22;9828:34;;;9813:49;;9248:621;:::o;9828:34::-;;;;;;;;;;;;;;;;:::i;:::-;;;2243:8010;;;;;9248:621;:::o;9828:34::-;;;;;9645:158;9757:11;;;9645:158;;9585:17;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;2243:8010;;;9482:22;2243:8010;;;;;9536:98;2243:8010;;9617:17;;;;;9482:22;9617:17;;;;;;;;;9482:22;9617:17;;;9536:98;;;;9617:17;;;;;;;;;;;;;;:::i;:::-;;;;9536;;;;;;;;;;;;;;:::i;:::-;;;;;2243:8010;;;9482:22;2243:8010;;;;;9482:22;;;;;;;;;;;;;;;;;;:::i;:::-;;;2243:8010;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;9482:22;;;;;;-1:-1:-1;9482:22:6;;;2243:8010;;;9482:22;2243:8010;;;;;10457:340:1;-1:-1:-1;;;;;2243:8010:6;;;;10558:19:1;;2243:8010:6;;;10636:21:1;;;2243:8010:6;;;10758:32:1;2243:8010:6;;10575:1:1;2243:8010:6;10707:11:1;2243:8010:6;;;10575:1:1;2243:8010:6;;10575:1:1;2243:8010:6;;;;;10575:1:1;2243:8010:6;;;;;;;10758:32:1;10457:340::o;2243:8010:6:-;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;1359:130:0;1273:6;2243:8010:6;-1:-1:-1;;;;;2243:8010:6;734:10:4;1422:23:0;2243:8010:6;;1359:130:0:o;2243:8010:6:-;;;;;;;;;;;;;;;;;;;;;;;;;4995:908;2243:8010;;;;;;;3519:9:1;2243:8010:6;3519:9:1;2243:8010:6;;;;3519:9:1;2243:8010:6;;5122:25;2243:8010;;-1:-1:-1;;;;;2243:8010:6;;3519:9:1;2243:8010:6;;;5187:12;2243:8010;;;;;;;;5187:38;;;;4995:908;5183:122;;-1:-1:-1;;;;;2243:8010:6;;;5330:8;2243:8010;;;5322:16;2243:8010;;3519:9:1;7524:40:6;5330:8;7524:40;:::i;:::-;7574:19;3519:9:1;7607:10:6;;;:23;;;4995:908;7603:93;;4995:908;7743:20;;;;:::i;:::-;7727:36;;;7723:233;;4995:908;2243:8010;;;5463:8;2243:8010;;;;5462:9;:41;;;4995:908;5462:76;;;4995:908;5462:118;;;4995:908;5445:259;;4995:908;5718:19;;:37;;;4995:908;5714:139;;5889:6;;;;;:::i;:::-;4995:908::o;5714:139::-;6876:5;;2243:8010;6937:12;2243:8010;6854:18;6863:9;2243:8010;6854:18;;:::i;:::-;6917;2243:8010;;;;;-1:-1:-1;;;;;2243:8010:6;5330:8;6937:12;:::i;:::-;5330:8;-1:-1:-1;;;;;2243:8010:6;6960:26;;;;2243:8010;;-1:-1:-1;;;;;;6960:26:6;;2243:8010;3519:9:1;2243:8010:6;6960:26;2243:8010;3519:9:1;5330:8:6;-1:-1:-1;;;;;2243:8010:6;6960:26;;;;;;7291:34;6960:26;7291:34;6960:26;7291:21;6960:26;;;5714:139;2243:8010;7001:20;2243:8010;;;;;;7001:20;2243:8010;7055:18;7064:9;2243:8010;7055:18;;:::i;:::-;2243:8010;;7114:16;7123:7;2243:8010;7114:16;;:::i;:::-;2243:8010;7184:10;;;;;:::i;:::-;7227:13;2243:8010;7242:12;;2243:8010;;-1:-1:-1;;;;;2243:8010:6;7242:12;;:::i;:::-;7291:21;:::i;:34::-;;;:::i;6960:26::-;;;;:::i;:::-;;;;;2243:8010;;;3519:9:1;2243:8010:6;;;;;5718:37;-1:-1:-1;;;;;;2243:8010:6;;;5330:8;2243:8010;;;5741:14;5718:37;;5445:259;-1:-1:-1;;2243:8010:6;;;5616:4;2243:8010;5463:8;2243:8010;6088:440;;:::i;:::-;5463:8;2243:8010;;5463:8;2243:8010;5445:259;;;5462:118;-1:-1:-1;5562:18:6;2243:8010;-1:-1:-1;;;;;2243:8010:6;;;;;5554:26;;5462:118;;:76;5519:19;;;5462:76;;:41;-1:-1:-1;;;;;;2243:8010:6;;;5330:8;2243:8010;;;5322:16;;5462:41;;7723:233;2243:8010;;-1:-1:-1;;;8210:29:6;;3519:9:1;;-1:-1:-1;2243:8010:6;7795:150;;2243:8010;;8210:29;2243:8010;5330:8;-1:-1:-1;;;;;2243:8010:6;8210:29;;;;;;;3519:9:1;8210:29:6;;;7723:233;-1:-1:-1;2243:8010:6;;-1:-1:-1;;;8283:20:6;;8184:55;;2243:8010;;;8210:29;2243:8010;8283:10;-1:-1:-1;;;;;2243:8010:6;8283:20;;;;;;;8210:29;8283:20;2243:8010;8283:20;3519:9:1;8283:20:6;;;7723:233;-1:-1:-1;2243:8010:6;;-1:-1:-1;;;8265:47:6;;2243:8010;;;;;-1:-1:-1;;;;;2243:8010:6;8265:47;;;;;;;3519:9:1;8265:47:6;;;7723:233;-1:-1:-1;2243:8010:6;;-1:-1:-1;;;8381:23:6;;2243:8010;-1:-1:-1;;;;;2243:8010:6;;;8335:19;;;2243:8010;;;;8210:29;;2243:8010;;5330:8;2243:8010;8381:23;;;;;;;;;3519:9:1;8381:23:6;;;7723:233;-1:-1:-1;8419:20:6;;;;;;;7723:233;8415:460;;7723:233;8903:13;;;;;:::i;:::-;8930:20;;;;8970:11;;;;8966:96;;8926:310;;;;7723:233;;;;;8966:96;9013:27;9023:16;;;;;;:::i;:::-;9013:27;:::i;:::-;-1:-1:-1;;2243:8010:6;;;;;;;8966:96;;;;8926:310;9131:25;;;9180:31;9131:25;;;9181:24;9131:25;9130:32;9131:25;;;:::i;:::-;9130:32;:::i;:::-;9181:24;;;:::i;9180:31::-;672:5:5;;;;;;:13;8926:310:6;;672:13:5;;;8926:310:6;;8415:460;8481:7;;8471:18;8481:7;;8523:17;8481:7;;:::i;8471:18::-;8523:17;;:::i;:::-;8558;;;;8554:311;;8415:460;;;;;;8554:311;8634:17;;;;;8615:37;8634:17;;;;:::i;:::-;8615:37;;:::i;:::-;2243:8010;;8655:1;2243:8010;;;8655:1;2243:8010;;;;;;;;8704:1;2243:8010;;;8704:1;2243:8010;;;;;;;;;8655:1;8696:21;2243:8010;;8704:1;8752:23;2243:8010;;8696:21;:::i;:::-;2243:8010;;8752:23;:::i;:::-;8797:18;;8793:57;;8554:311;;;;;;8793:57;8903:13;8817:33;;;;;;;;:::i;:::-;8793:57;;;;;;8419:20;8428:11;;;;8419:20;;8381:23;;;;;;2243:8010;8381:23;;2243:8010;8381:23;;;;;;2243:8010;8381:23;;;:::i;:::-;;;2243:8010;;;;;;;;;;;8381:23;;;;;-1:-1:-1;8381:23:6;;8265:47;;;;2243:8010;8265:47;2243:8010;8265:47;;;;;;;:::i;:::-;;;;8283:20;;;;;;;;;;;;;;:::i;:::-;;;;8210:29;;;;2243:8010;8210:29;;2243:8010;8210:29;;;;;;2243:8010;8210:29;;;:::i;:::-;;;2243:8010;;;;;8210:29;;;;;;;-1:-1:-1;8210:29:6;;7603:93;7661:15;7743:20;7660:25;7661:15;;;;;:::i;7660:25::-;7603:93;;;;7607:23;7621:9;;;;7607:23;;2243:8010;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;5183:122;5267:6;;;;;:::i;5187:38::-;-1:-1:-1;;;;;;2243:8010:6;;3519:9:1;2243:8010:6;;;;;;;;;5187:38;;2243:8010;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;7456:788:1;-1:-1:-1;;;;;2243:8010:6;7552:18:1;;2243:8010:6;;;-1:-1:-1;2243:8010:6;-1:-1:-1;2243:8010:6;;;-1:-1:-1;2243:8010:6;;7801:21:1;;;2243:8010:6;;;;;-1:-1:-1;2243:8010:6;-1:-1:-1;2243:8010:6;;;;-1:-1:-1;2243:8010:6;;8163:26:1;2243:8010:6;2339:42;2243:8010;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;8163:26:1;7456:788::o;2243:8010:6:-;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;7456:788:1;-1:-1:-1;;;;;2243:8010:6;;;;7552:18:1;;2243:8010:6;;;7630:16:1;;;2243:8010:6;;;7568:1:1;2243:8010:6;7568:1:1;2243:8010:6;;;7568:1:1;2243:8010:6;;7801:21:1;;;2243:8010:6;;;8163:26:1;2243:8010:6;;;;7568:1:1;2243:8010:6;7568:1:1;2243:8010:6;;;;7568:1:1;2243:8010:6;;;7568:1:1;2243:8010:6;;7568:1:1;2243:8010:6;;;;;;;;;;;;8163:26:1;7456:788::o;2243:8010:6:-;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;2977:197;6165:16;2243:8010;3027:12;2243:8010;3027:16;;;;:57;;;;2977:197;3023:94;;;6472:12;6418:5;6398;6343:39;6232:8;6219:22;6343:19;6279:30;6219:22;;;:::i;:::-;6279:15;;;;;:30;:::i;:::-;2243:8010;6351:11;2243:8010;6343:19;;:::i;:::-;:39;:::i;:::-;2243:8010;;6472:12;;:::i;:::-;-1:-1:-1;;;;;2243:8010:6;6495:26;;;;;-1:-1:-1;2243:8010:6;;6495:26;2243:8010;;;;;;;;;6495:26;;;;;;;;;;2977:197;6279:15;;3027:12;2243:8010;2977:197::o;6495:26::-;;;;:::i;:::-;;;;3023:94;3100:7;:::o;3027:57::-;3065:19;;;;;:::i;:::-;3047:15;:37;3027:57;;;2243:8010;;;;;;;;;;:::o;6530:1642:5:-;6601:6;;6597:45;;8144:10;7344:7;6606:1;2243:8010:6;;8769:3:5;2243:8010:6;8760:16:5;8756:99;;6530:1642;2243:8010:6;;8881:2:5;2243:8010:6;8872:15:5;8868:96;;6530:1642;2243:8010:6;;8990:2:5;2243:8010:6;8981:15:5;8977:96;;6530:1642;2243:8010:6;;9099:2:5;2243:8010:6;9090:15:5;9086:96;;6530:1642;2243:8010:6;;9208:1:5;2243:8010:6;9199:14:5;9195:93;;6530:1642;2243:8010:6;;9314:1:5;2243:8010:6;9305:14:5;9301:93;;6530:1642;2243:8010:6;;9420:1:5;2243:8010:6;9411:14:5;9407:93;;6530:1642;9526:1;;2243:8010:6;;;;;;9513:64:5;;6530:1642;2243:8010:6;;7801:10:5;;;;:::i;:::-;2243:8010:6;;;7850:10:5;;;;:::i;:::-;2243:8010:6;;;7899:10:5;;;;:::i;:::-;2243:8010:6;;;7948:10:5;;;;:::i;:::-;2243:8010:6;;;7997:10:5;;;;:::i;:::-;2243:8010:6;;;8046:10:5;;;;:::i;:::-;2243:8010:6;;;8095:10:5;;;;:::i;:::-;2243:8010:6;;;8144:10:5;;;:::i;:::-;672:5;;;;;;:13;6530:1642;:::o;672:13::-;;;6530:1642;:::o;9513:64::-;2243:8010:6;9513:64:5;;;9407:93;9420:1;9445:11;;2243:8010:6;;9407:93:5;;;;9301;9314:1;9339:11;;2243:8010:6;;9301:93:5;;;;9195;9208:1;9233:11;;2243:8010:6;;9195:93:5;;;;9086:96;9099:2;9125:12;;2243:8010:6;;9086:96:5;;;;8977;8990:2;9016:12;;2243:8010:6;;8977:96:5;;;;8868;8881:2;8907:12;;2243:8010:6;;8868:96:5;;;;8756:99;8796:13;;;8769:3;8756:99;;;;6597:45;6623:8;6606:1;6623:8;:::o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122028a19f191e8dc50149a5f2e355ef1763e448942ba99716212ae19ed7aefb1c8564736f6c63430008160033","offset":7065}},"immutableReferences":{"1868":[{"start":947,"length":32},{"start":5097,"length":32}],"1870":[{"start":1083,"length":32},{"start":2131,"length":32},{"start":4285,"length":32},{"start":4330,"length":32},{"start":4498,"length":32},{"start":4536,"length":32},{"start":4607,"length":32},{"start":4829,"length":32},{"start":4948,"length":32},{"start":5016,"length":32},{"start":5243,"length":32},{"start":6555,"length":32}],"1872":[{"start":1452,"length":32}]},"transformations":[{"id":"1868","type":"replace","offset":947,"reason":"immutable"},{"id":"1868","type":"replace","offset":5097,"reason":"immutable"},{"id":"1870","type":"replace","offset":1083,"reason":"immutable"},{"id":"1870","type":"replace","offset":2131,"reason":"immutable"},{"id":"1870","type":"replace","offset":4285,"reason":"immutable"},{"id":"1870","type":"replace","offset":4330,"reason":"immutable"},{"id":"1870","type":"replace","offset":4498,"reason":"immutable"},{"id":"1870","type":"replace","offset":4536,"reason":"immutable"},{"id":"1870","type":"replace","offset":4607,"reason":"immutable"},{"id":"1870","type":"replace","offset":4829,"reason":"immutable"},{"id":"1870","type":"replace","offset":4948,"reason":"immutable"},{"id":"1870","type":"replace","offset":5016,"reason":"immutable"},{"id":"1870","type":"replace","offset":5243,"reason":"immutable"},{"id":"1870","type":"replace","offset":6555,"reason":"immutable"},{"id":"1872","type":"replace","offset":1452,"reason":"immutable"}],"transformationValues":{"immutables":{"1868":"0x00000000000000000000000010ed43c718714eb63d5aa57b78b54704e256024e","1870":"0x00000000000000000000000047c8c3b123de467892ac7df6dfcf7ca3db901733","1872":"0x00000000000000000000000055d398326f99059ff775485246999027b3197955"}}},"deployment":{"transactionHash":null,"blockNumber":null,"transactionIndex":null,"deployer":null},"sources":{"dependencies/@openzeppelin-contracts-4.9.6/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\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"},"dependencies/@openzeppelin-contracts-4.9.6/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"src/supperLucky/SupperLuckyToken.sol":{"content":"/**\n *Submitted for verification at BscScan.com on 2024-04-27\n */\n\n// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.22;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/utils/math/Math.sol\";\ninterface ISwapPair {\n    function getReserves()\n        external\n        view\n        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\n\n    function token0() external view returns (address);\n\n    function token1() external view returns (address);\n\n    function totalSupply() external view returns (uint);\n\n    function kLast() external view returns (uint);\n\n    function sync() external;\n\n    function balanceOf(address account) external view returns (uint256);\n}\n\ninterface IUniswapV2Router01 {\n    function factory() external pure returns (address);\n\n    function WETH() external pure returns (address);\n\n    function addLiquidity(\n        address tokenA,\n        address tokenB,\n        uint256 amountADesired,\n        uint256 amountBDesired,\n        uint256 amountAMin,\n        uint256 amountBMin,\n        address to,\n        uint256 deadline\n    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);\n}\n\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\n    function getAmountsOut(\n        uint256 amountIn,\n        address[] calldata path\n    ) external view returns (uint256[] memory amounts);\n\n    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external;\n\n    function swapExactTokensForTokens(\n        uint amountIn,\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external returns (uint[] memory amounts);\n}\n\ninterface IUniswapV2Factory {\n    function createPair(\n        address tokenA,\n        address tokenB\n    ) external returns (address pair);\n\n    function getPair(\n        address tokenA,\n        address tokenB\n    ) external view returns (address);\n\n    function feeTo() external view returns (address);\n}\n\ncontract SupperLuckyToken is ERC20, Ownable {\n    address public constant DEAD_WALLET =\n        0x000000000000000000000000000000000000dEaD;\n    uint256 private miningFee = 4000;\n    uint256 public brunFee = 500;\n    uint256 private rewardFee = 1500;\n\n    IUniswapV2Router02 public immutable swapRouter;\n    address public immutable usdtPair;\n    address public immutable usdtAddress;\n\n    address public miningPoolContract;\n    address public claimContract;\n\n    mapping(address => bool) public feeWhiteList;\n\n    uint256 public burnCoolDownTime = 60 minutes;\n    uint256 public lastBurnTime;\n    uint256 public burnPercent = 200;\n\n    bool private swapping;\n\n    event FeeWhiteListUpdated(address indexed account, bool status);\n\n    modifier burnCoolDown(uint256 time) {\n        if (lastBurnTime > 0 && block.timestamp < lastBurnTime + time) {\n            return;\n        }\n        _;\n        lastBurnTime = block.timestamp;\n    }\n\n    constructor(\n        string memory name_,\n        string memory symbol_,\n        address deployer\n    ) ERC20(name_, symbol_) {\n        _mint(deployer, 10000000000e18);\n        _transferOwnership(deployer);\n\n        if (block.chainid == 97) {\n            usdtAddress = 0xC5A25d89470e873E8f37eA2B2E8d2e66181DDEF8;\n            swapRouter = IUniswapV2Router02(\n                0xD99D1c33F9fC3444f8101754aBC46c52416550D1\n            );\n        } else {\n            usdtAddress = 0x55d398326f99059fF775485246999027B3197955;\n            swapRouter = IUniswapV2Router02(\n                0x10ED43C718714eb63d5aA57B78B54704E256024E\n            );\n        }\n        // 创建交易对\n        usdtPair = IUniswapV2Factory(swapRouter.factory()).createPair(\n            address(this),\n            usdtAddress\n        );\n        // 设置白名单\n        _setFeeWhiteList(deployer, true);\n    }\n\n    // 管理函数\n    function setFeeWhiteList(address addr, bool enable) external onlyOwner {\n        _setFeeWhiteList(addr, enable);\n    }\n\n    function setContractAddress(\n        address _miningPoolContract,\n        address _claimContract\n    ) external onlyOwner {\n        miningPoolContract = _miningPoolContract;\n        claimContract = _claimContract;\n    }\n\n    function setBurnCoolDownTime(uint256 _burnCoolDownTime) external onlyOwner {\n        burnCoolDownTime = _burnCoolDownTime;\n    }\n\n    function setBurnPercent(uint256 _burnPercent) external onlyOwner {\n        burnPercent = _burnPercent;\n    }\n\n    function setMiningFee(uint256 _miningFee) external onlyOwner {\n        miningFee = _miningFee;\n    }\n\n    function setBrunFee(uint256 _brunFee) external onlyOwner {\n        brunFee = _brunFee;\n    }\n\n    function setRewardFee(uint256 _rewardFee) external onlyOwner {\n        rewardFee = _rewardFee;\n    }\n\n    function _transfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal override {\n        require(balanceOf(from) >= amount, \"Balance insufficient\");\n\n        if (feeWhiteList[from] || feeWhiteList[to]) {\n            super._transfer(from, to, amount);\n            return;\n        }\n        require(from != usdtPair, \"cannot buy or remove lp\");\n\n        uint256 addLPLiquidity = _isAddLiquidity(usdtPair, amount);\n        if (\n            !swapping &&\n            from != usdtPair &&\n            0 == addLPLiquidity &&\n            from != miningPoolContract\n        ) {\n            swapping = true;\n            autoBurnLiquidityPairTokens();\n            swapping = false;\n        }\n\n        if (addLPLiquidity <= 0 && to == usdtPair) {\n            //卖出\n            sellTransfer(amount, from, to);\n            return;\n        }\n\n        super._transfer(from, to, amount);\n    }\n\n    // 内部函数\n    function _setFeeWhiteList(address addr, bool enable) private {\n        feeWhiteList[addr] = enable;\n        emit FeeWhiteListUpdated(addr, enable);\n    }\n\n    function autoBurnLiquidityPairTokens()\n        internal\n        burnCoolDown(burnCoolDownTime)\n    {\n        (, uint256 rThis, ) = _getReserves(usdtPair);\n        uint256 timeSinceLastBurn = block.timestamp - lastBurnTime;\n        uint256 amountToBurn = (rThis * burnPercent * timeSinceLastBurn) /\n            10000 /\n            86400;\n        super._transfer(usdtPair, DEAD_WALLET, amountToBurn);\n        ISwapPair(usdtPair).sync();\n    }\n\n    function ownerBurnLiquidityPairTokens(uint256 amount) public onlyOwner {\n        super._transfer(usdtPair, owner(), amount);\n        ISwapPair(usdtPair).sync();\n    }\n\n    event SellTransfer(uint256 amount);\n\n    function sellTransfer(uint256 amount, address from, address to) internal {\n        uint256 miningAmount = (amount * miningFee) / 10000;\n        super._transfer(usdtPair, miningPoolContract, miningAmount);\n        ISwapPair(usdtPair).sync();\n        emit SellTransfer(amount);\n        uint256 rewardAmount = (amount * rewardFee) / 10000;\n        uint256 burnAmount = (amount * brunFee) / 10000;\n        super._transfer(from, DEAD_WALLET, burnAmount);\n        super._transfer(from, claimContract, rewardAmount);\n        super._transfer(from, to, amount - rewardAmount - burnAmount);\n    }\n\n    function _isAddLiquidity(\n        address pair,\n        uint256 amount\n    ) internal view returns (uint256 liquidity) {\n        (uint256 rOther, uint256 rThis, uint256 balanceOther) = _getReserves(\n            pair\n        );\n        uint256 amountOther;\n        if (rOther > 0 && rThis > 0) {\n            amountOther = (amount * rOther) / rThis;\n        }\n        //isAddLP\n        if (balanceOther >= rOther + amountOther) {\n            (liquidity, ) = _calLiquidity(\n                pair,\n                balanceOther,\n                amount,\n                rOther,\n                rThis\n            );\n        }\n    }\n\n    function _calLiquidity(\n        address pair,\n        uint256 balanceA,\n        uint256 amount,\n        uint256 r0,\n        uint256 r1\n    ) private view returns (uint256 liquidity, uint256 feeToLiquidity) {\n        uint256 pairTotalSupply = ISwapPair(pair).totalSupply();\n        address feeTo = IUniswapV2Factory(swapRouter.factory()).feeTo();\n        bool feeOn = feeTo != address(0);\n        uint256 _kLast = ISwapPair(pair).kLast();\n\n        if (feeOn && _kLast != 0) {\n            uint256 rootK = Math.sqrt(r0 * r1);\n            uint256 rootKLast = Math.sqrt(_kLast);\n            if (rootK > rootKLast) {\n                uint256 numerator = pairTotalSupply * (rootK - rootKLast) * 3;\n                uint256 denominator = rootK * 5 + rootKLast;\n                feeToLiquidity = numerator / denominator;\n                if (feeToLiquidity > 0) pairTotalSupply += feeToLiquidity;\n            }\n        }\n\n        uint256 amount0 = balanceA - r0;\n        if (pairTotalSupply == 0) {\n            if (amount0 > 0) {\n                liquidity = Math.sqrt(amount0 * amount) - 1000;\n            }\n        } else {\n            liquidity = Math.min(\n                (amount0 * pairTotalSupply) / r0,\n                (amount * pairTotalSupply) / r1\n            );\n        }\n    }\n\n    function _getReserves(\n        address pair\n    )\n        public\n        view\n        returns (uint256 rOther, uint256 rThis, uint256 balanceOther)\n    {\n        ISwapPair mainPair = ISwapPair(pair);\n        (uint r0, uint256 r1, ) = mainPair.getReserves();\n\n        address tokenOther = mainPair.token0() == address(this)\n            ? mainPair.token1()\n            : mainPair.token0();\n\n        if (tokenOther < address(this)) {\n            rOther = r0;\n            rThis = r1;\n        } else {\n            rOther = r1;\n            rThis = r0;\n        }\n\n        balanceOther = IERC20(tokenOther).balanceOf(pair);\n    }\n\n    function _isRemoveLiquidity(\n        address pair,\n        uint256 amount\n    ) internal view returns (uint256 liquidity) {\n        (uint256 rOther, , uint256 balanceOther) = _getReserves(pair);\n\n        if (balanceOther <= rOther) {\n            liquidity =\n                (amount * ISwapPair(pair).totalSupply()) /\n                (balanceOf(pair) - amount);\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.22+commit.4fc1097e","compilerSettings":{"viaIR":true,"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"shanghai","remappings":["@ensdomains/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/@ensdomains/","@openzeppelin-contracts-4.9.6/=dependencies/@openzeppelin-contracts-4.9.6/","@openzeppelin-contracts-upgradeable-4.9.6/=dependencies/@openzeppelin-contracts-upgradeable-4.9.6/","@openzeppelin-upgradeable/contracts/=dependencies/@openzeppelin-contracts-upgradeable-4.9.6/","@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-4.9.6/","@uniswap-v2-core-1.0.1/=dependencies/@uniswap-v2-core-1.0.1/","@uniswap-v2-periphery-1.1.0-beta.0/=dependencies/@uniswap-v2-periphery-1.1.0-beta.0/","@uniswap-v3-core-1.0.2-solc-0.8-simulate/=dependencies/@uniswap-v3-core-1.0.2-solc-0.8-simulate/contracts/","@uniswap-v3-core/=dependencies/@uniswap-v3-core-1.0.2-solc-0.8-simulate/","@uniswap-v3-periphery-1.4.4/=dependencies/@uniswap-v3-periphery-1.4.4/contracts/","@uniswap-v3-periphery/=dependencies/@uniswap-v3-periphery-1.4.4/","@uniswap/=dependencies/@uniswap-v2-periphery-1.1.0-beta.0/node_modules/@uniswap/","base64-sol/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/base64-sol/","forge-std-1.9.6/=dependencies/forge-std-1.9.6/src/","forge-std/=lib/forge-std/src/","hardhat/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/hardhat/"]},"name":"SupperLuckyToken","fullyQualifiedName":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},"abi":[{"type":"constructor","inputs":[{"name":"name_","type":"string","internalType":"string"},{"name":"symbol_","type":"string","internalType":"string"},{"name":"deployer","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"FeeWhiteListUpdated","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"status","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"SellTransfer","type":"event","inputs":[{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DEAD_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"_getReserves","type":"function","inputs":[{"name":"pair","type":"address","internalType":"address"}],"outputs":[{"name":"rOther","type":"uint256","internalType":"uint256"},{"name":"rThis","type":"uint256","internalType":"uint256"},{"name":"balanceOther","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"brunFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"burnCoolDownTime","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"burnPercent","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claimContract","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"feeWhiteList","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"lastBurnTime","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"miningPoolContract","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownerBurnLiquidityPairTokens","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBrunFee","type":"function","inputs":[{"name":"_brunFee","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBurnCoolDownTime","type":"function","inputs":[{"name":"_burnCoolDownTime","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBurnPercent","type":"function","inputs":[{"name":"_burnPercent","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setContractAddress","type":"function","inputs":[{"name":"_miningPoolContract","type":"address","internalType":"address"},{"name":"_claimContract","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setFeeWhiteList","type":"function","inputs":[{"name":"addr","type":"address","internalType":"address"},{"name":"enable","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMiningFee","type":"function","inputs":[{"name":"_miningFee","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRewardFee","type":"function","inputs":[{"name":"_rewardFee","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"swapRouter","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IUniswapV2Router02"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"usdtAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"usdtPair","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"address","name":"deployer","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"FeeWhiteListUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SellTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DEAD_WALLET","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"_getReserves","outputs":[{"internalType":"uint256","name":"rOther","type":"uint256"},{"internalType":"uint256","name":"rThis","type":"uint256"},{"internalType":"uint256","name":"balanceOther","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"brunFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnCoolDownTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"feeWhiteList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastBurnTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"miningPoolContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ownerBurnLiquidityPairTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_brunFee","type":"uint256"}],"name":"setBrunFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_burnCoolDownTime","type":"uint256"}],"name":"setBurnCoolDownTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_burnPercent","type":"uint256"}],"name":"setBurnPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_miningPoolContract","type":"address"},{"internalType":"address","name":"_claimContract","type":"address"}],"name":"setContractAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bool","name":"enable","type":"bool"}],"name":"setFeeWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_miningFee","type":"uint256"}],"name":"setMiningFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardFee","type":"uint256"}],"name":"setRewardFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapRouter","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"usdtAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"usdtPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}],"devdoc":{"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"kind":"dev","methods":{"allowance(address,address)":{"details":"See {IERC20-allowance}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"src/supperLucky/SupperLuckyToken.sol":"SupperLuckyToken"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@ensdomains/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/@ensdomains/",":@openzeppelin-contracts-4.9.6/=dependencies/@openzeppelin-contracts-4.9.6/",":@openzeppelin-contracts-upgradeable-4.9.6/=dependencies/@openzeppelin-contracts-upgradeable-4.9.6/",":@openzeppelin-upgradeable/contracts/=dependencies/@openzeppelin-contracts-upgradeable-4.9.6/",":@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-4.9.6/",":@uniswap-v2-core-1.0.1/=dependencies/@uniswap-v2-core-1.0.1/",":@uniswap-v2-periphery-1.1.0-beta.0/=dependencies/@uniswap-v2-periphery-1.1.0-beta.0/",":@uniswap-v3-core-1.0.2-solc-0.8-simulate/=dependencies/@uniswap-v3-core-1.0.2-solc-0.8-simulate/contracts/",":@uniswap-v3-core/=dependencies/@uniswap-v3-core-1.0.2-solc-0.8-simulate/",":@uniswap-v3-periphery-1.4.4/=dependencies/@uniswap-v3-periphery-1.4.4/contracts/",":@uniswap-v3-periphery/=dependencies/@uniswap-v3-periphery-1.4.4/",":@uniswap/=dependencies/@uniswap-v2-periphery-1.1.0-beta.0/node_modules/@uniswap/",":base64-sol/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/base64-sol/",":forge-std-1.9.6/=dependencies/forge-std-1.9.6/src/",":forge-std/=lib/forge-std/src/",":hardhat/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/hardhat/"],"viaIR":true},"sources":{"dependencies/@openzeppelin-contracts-4.9.6/access/Ownable.sol":{"keccak256":"0xba43b97fba0d32eb4254f6a5a297b39a19a247082a02d6e69349e071e2946218","license":"MIT","urls":["bzz-raw://fc980984badf3984b6303b377711220e067722bbd6a135b24669ff5069ef9f32","dweb:/ipfs/QmPHXMSXj99XjSVM21YsY6aNtLLjLVXDbyN76J5HQYvvrz"]},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/ERC20.sol":{"keccak256":"0xa56ca923f70c1748830700250b19c61b70db9a683516dc5e216694a50445d99c","license":"MIT","urls":["bzz-raw://cac938788bc4be12101e59d45588b4e059579f4e61062e1cda8d6b06c0191b15","dweb:/ipfs/QmV2JKCyjTVH3rkWNrfdJRhAT7tZ3usAN2XcnD4h53Mvih"]},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/IERC20.sol":{"keccak256":"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305","license":"MIT","urls":["bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5","dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53"]},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca","license":"MIT","urls":["bzz-raw://5a376d3dda2cb70536c0a45c208b29b34ac560c4cb4f513a42079f96ba47d2dd","dweb:/ipfs/QmZQg6gn1sUpM8wHzwNvSnihumUCAhxD119MpXeKp8B9s8"]},"dependencies/@openzeppelin-contracts-4.9.6/utils/Context.sol":{"keccak256":"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439","license":"MIT","urls":["bzz-raw://a367861093b74443b137564d3f3c472f70bcf114739e62059c939f25e315706c","dweb:/ipfs/Qmd7JMpcxD9RuQjK3uM3EzJUgSqdN8vzp8eytEiuwxQJ6h"]},"dependencies/@openzeppelin-contracts-4.9.6/utils/math/Math.sol":{"keccak256":"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3","license":"MIT","urls":["bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c","dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS"]},"src/supperLucky/SupperLuckyToken.sol":{"keccak256":"0x4c397cfdb272680d3475846c568984883e7ba1fbfd6ed83b2daa7cef803afd14","license":"UNLICENSED","urls":["bzz-raw://329aca46149b3fbdbc02dfcce8500a2da8b93effd94c6b65aa79e475bab28583","dweb:/ipfs/QmSAx9pc17LbRwxvk56hcwB7EL9PXVwFQHPbNijE4hrSXZ"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":128,"label":"_balances","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":134,"label":"_allowances","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"2","type":"t_uint256","astId":136,"label":"_totalSupply","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"3","type":"t_string_storage","astId":138,"label":"_name","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"4","type":"t_string_storage","astId":140,"label":"_symbol","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"5","type":"t_address","astId":7,"label":"_owner","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"6","type":"t_uint256","astId":1859,"label":"miningFee","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"7","type":"t_uint256","astId":1862,"label":"brunFee","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"8","type":"t_uint256","astId":1865,"label":"rewardFee","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"9","type":"t_address","astId":1874,"label":"miningPoolContract","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"10","type":"t_address","astId":1876,"label":"claimContract","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"11","type":"t_mapping(t_address,t_bool)","astId":1880,"label":"feeWhiteList","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"12","type":"t_uint256","astId":1883,"label":"burnCoolDownTime","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"13","type":"t_uint256","astId":1885,"label":"lastBurnTime","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"14","type":"t_uint256","astId":1888,"label":"burnPercent","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"15","type":"t_bool","astId":1890,"label":"swapping","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"sourceIds":{"src/supperLucky/SupperLuckyToken.sol":{"id":6},"dependencies/@openzeppelin-contracts-4.9.6/utils/Context.sol":{"id":4},"dependencies/@openzeppelin-contracts-4.9.6/access/Ownable.sol":{"id":0},"dependencies/@openzeppelin-contracts-4.9.6/utils/math/Math.sol":{"id":5},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/ERC20.sol":{"id":1},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/IERC20.sol":{"id":2},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/extensions/IERC20Metadata.sol":{"id":3}},"additionalInput":null,"stdJsonInput":{"sources":{"src/supperLucky/SupperLuckyToken.sol":{"content":"/**\n *Submitted for verification at BscScan.com on 2024-04-27\n */\n\n// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.22;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/utils/math/Math.sol\";\ninterface ISwapPair {\n    function getReserves()\n        external\n        view\n        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\n\n    function token0() external view returns (address);\n\n    function token1() external view returns (address);\n\n    function totalSupply() external view returns (uint);\n\n    function kLast() external view returns (uint);\n\n    function sync() external;\n\n    function balanceOf(address account) external view returns (uint256);\n}\n\ninterface IUniswapV2Router01 {\n    function factory() external pure returns (address);\n\n    function WETH() external pure returns (address);\n\n    function addLiquidity(\n        address tokenA,\n        address tokenB,\n        uint256 amountADesired,\n        uint256 amountBDesired,\n        uint256 amountAMin,\n        uint256 amountBMin,\n        address to,\n        uint256 deadline\n    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);\n}\n\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\n    function getAmountsOut(\n        uint256 amountIn,\n        address[] calldata path\n    ) external view returns (uint256[] memory amounts);\n\n    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external;\n\n    function swapExactTokensForTokens(\n        uint amountIn,\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external returns (uint[] memory amounts);\n}\n\ninterface IUniswapV2Factory {\n    function createPair(\n        address tokenA,\n        address tokenB\n    ) external returns (address pair);\n\n    function getPair(\n        address tokenA,\n        address tokenB\n    ) external view returns (address);\n\n    function feeTo() external view returns (address);\n}\n\ncontract SupperLuckyToken is ERC20, Ownable {\n    address public constant DEAD_WALLET =\n        0x000000000000000000000000000000000000dEaD;\n    uint256 private miningFee = 4000;\n    uint256 public brunFee = 500;\n    uint256 private rewardFee = 1500;\n\n    IUniswapV2Router02 public immutable swapRouter;\n    address public immutable usdtPair;\n    address public immutable usdtAddress;\n\n    address public miningPoolContract;\n    address public claimContract;\n\n    mapping(address => bool) public feeWhiteList;\n\n    uint256 public burnCoolDownTime = 60 minutes;\n    uint256 public lastBurnTime;\n    uint256 public burnPercent = 200;\n\n    bool private swapping;\n\n    event FeeWhiteListUpdated(address indexed account, bool status);\n\n    modifier burnCoolDown(uint256 time) {\n        if (lastBurnTime > 0 && block.timestamp < lastBurnTime + time) {\n            return;\n        }\n        _;\n        lastBurnTime = block.timestamp;\n    }\n\n    constructor(\n        string memory name_,\n        string memory symbol_,\n        address deployer\n    ) ERC20(name_, symbol_) {\n        _mint(deployer, 10000000000e18);\n        _transferOwnership(deployer);\n\n        if (block.chainid == 97) {\n            usdtAddress = 0xC5A25d89470e873E8f37eA2B2E8d2e66181DDEF8;\n            swapRouter = IUniswapV2Router02(\n                0xD99D1c33F9fC3444f8101754aBC46c52416550D1\n            );\n        } else {\n            usdtAddress = 0x55d398326f99059fF775485246999027B3197955;\n            swapRouter = IUniswapV2Router02(\n                0x10ED43C718714eb63d5aA57B78B54704E256024E\n            );\n        }\n        // 创建交易对\n        usdtPair = IUniswapV2Factory(swapRouter.factory()).createPair(\n            address(this),\n            usdtAddress\n        );\n        // 设置白名单\n        _setFeeWhiteList(deployer, true);\n    }\n\n    // 管理函数\n    function setFeeWhiteList(address addr, bool enable) external onlyOwner {\n        _setFeeWhiteList(addr, enable);\n    }\n\n    function setContractAddress(\n        address _miningPoolContract,\n        address _claimContract\n    ) external onlyOwner {\n        miningPoolContract = _miningPoolContract;\n        claimContract = _claimContract;\n    }\n\n    function setBurnCoolDownTime(uint256 _burnCoolDownTime) external onlyOwner {\n        burnCoolDownTime = _burnCoolDownTime;\n    }\n\n    function setBurnPercent(uint256 _burnPercent) external onlyOwner {\n        burnPercent = _burnPercent;\n    }\n\n    function setMiningFee(uint256 _miningFee) external onlyOwner {\n        miningFee = _miningFee;\n    }\n\n    function setBrunFee(uint256 _brunFee) external onlyOwner {\n        brunFee = _brunFee;\n    }\n\n    function setRewardFee(uint256 _rewardFee) external onlyOwner {\n        rewardFee = _rewardFee;\n    }\n\n    function _transfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal override {\n        require(balanceOf(from) >= amount, \"Balance insufficient\");\n\n        if (feeWhiteList[from] || feeWhiteList[to]) {\n            super._transfer(from, to, amount);\n            return;\n        }\n        require(from != usdtPair, \"cannot buy or remove lp\");\n\n        uint256 addLPLiquidity = _isAddLiquidity(usdtPair, amount);\n        if (\n            !swapping &&\n            from != usdtPair &&\n            0 == addLPLiquidity &&\n            from != miningPoolContract\n        ) {\n            swapping = true;\n            autoBurnLiquidityPairTokens();\n            swapping = false;\n        }\n\n        if (addLPLiquidity <= 0 && to == usdtPair) {\n            //卖出\n            sellTransfer(amount, from, to);\n            return;\n        }\n\n        super._transfer(from, to, amount);\n    }\n\n    // 内部函数\n    function _setFeeWhiteList(address addr, bool enable) private {\n        feeWhiteList[addr] = enable;\n        emit FeeWhiteListUpdated(addr, enable);\n    }\n\n    function autoBurnLiquidityPairTokens()\n        internal\n        burnCoolDown(burnCoolDownTime)\n    {\n        (, uint256 rThis, ) = _getReserves(usdtPair);\n        uint256 timeSinceLastBurn = block.timestamp - lastBurnTime;\n        uint256 amountToBurn = (rThis * burnPercent * timeSinceLastBurn) /\n            10000 /\n            86400;\n        super._transfer(usdtPair, DEAD_WALLET, amountToBurn);\n        ISwapPair(usdtPair).sync();\n    }\n\n    function ownerBurnLiquidityPairTokens(uint256 amount) public onlyOwner {\n        super._transfer(usdtPair, owner(), amount);\n        ISwapPair(usdtPair).sync();\n    }\n\n    event SellTransfer(uint256 amount);\n\n    function sellTransfer(uint256 amount, address from, address to) internal {\n        uint256 miningAmount = (amount * miningFee) / 10000;\n        super._transfer(usdtPair, miningPoolContract, miningAmount);\n        ISwapPair(usdtPair).sync();\n        emit SellTransfer(amount);\n        uint256 rewardAmount = (amount * rewardFee) / 10000;\n        uint256 burnAmount = (amount * brunFee) / 10000;\n        super._transfer(from, DEAD_WALLET, burnAmount);\n        super._transfer(from, claimContract, rewardAmount);\n        super._transfer(from, to, amount - rewardAmount - burnAmount);\n    }\n\n    function _isAddLiquidity(\n        address pair,\n        uint256 amount\n    ) internal view returns (uint256 liquidity) {\n        (uint256 rOther, uint256 rThis, uint256 balanceOther) = _getReserves(\n            pair\n        );\n        uint256 amountOther;\n        if (rOther > 0 && rThis > 0) {\n            amountOther = (amount * rOther) / rThis;\n        }\n        //isAddLP\n        if (balanceOther >= rOther + amountOther) {\n            (liquidity, ) = _calLiquidity(\n                pair,\n                balanceOther,\n                amount,\n                rOther,\n                rThis\n            );\n        }\n    }\n\n    function _calLiquidity(\n        address pair,\n        uint256 balanceA,\n        uint256 amount,\n        uint256 r0,\n        uint256 r1\n    ) private view returns (uint256 liquidity, uint256 feeToLiquidity) {\n        uint256 pairTotalSupply = ISwapPair(pair).totalSupply();\n        address feeTo = IUniswapV2Factory(swapRouter.factory()).feeTo();\n        bool feeOn = feeTo != address(0);\n        uint256 _kLast = ISwapPair(pair).kLast();\n\n        if (feeOn && _kLast != 0) {\n            uint256 rootK = Math.sqrt(r0 * r1);\n            uint256 rootKLast = Math.sqrt(_kLast);\n            if (rootK > rootKLast) {\n                uint256 numerator = pairTotalSupply * (rootK - rootKLast) * 3;\n                uint256 denominator = rootK * 5 + rootKLast;\n                feeToLiquidity = numerator / denominator;\n                if (feeToLiquidity > 0) pairTotalSupply += feeToLiquidity;\n            }\n        }\n\n        uint256 amount0 = balanceA - r0;\n        if (pairTotalSupply == 0) {\n            if (amount0 > 0) {\n                liquidity = Math.sqrt(amount0 * amount) - 1000;\n            }\n        } else {\n            liquidity = Math.min(\n                (amount0 * pairTotalSupply) / r0,\n                (amount * pairTotalSupply) / r1\n            );\n        }\n    }\n\n    function _getReserves(\n        address pair\n    )\n        public\n        view\n        returns (uint256 rOther, uint256 rThis, uint256 balanceOther)\n    {\n        ISwapPair mainPair = ISwapPair(pair);\n        (uint r0, uint256 r1, ) = mainPair.getReserves();\n\n        address tokenOther = mainPair.token0() == address(this)\n            ? mainPair.token1()\n            : mainPair.token0();\n\n        if (tokenOther < address(this)) {\n            rOther = r0;\n            rThis = r1;\n        } else {\n            rOther = r1;\n            rThis = r0;\n        }\n\n        balanceOther = IERC20(tokenOther).balanceOf(pair);\n    }\n\n    function _isRemoveLiquidity(\n        address pair,\n        uint256 amount\n    ) internal view returns (uint256 liquidity) {\n        (uint256 rOther, , uint256 balanceOther) = _getReserves(pair);\n\n        if (balanceOther <= rOther) {\n            liquidity =\n                (amount * ISwapPair(pair).totalSupply()) /\n                (balanceOf(pair) - amount);\n        }\n    }\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\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"},"dependencies/@openzeppelin-contracts-4.9.6/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n"},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"shanghai","remappings":["@ensdomains/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/@ensdomains/","@openzeppelin-contracts-4.9.6/=dependencies/@openzeppelin-contracts-4.9.6/","@openzeppelin-contracts-upgradeable-4.9.6/=dependencies/@openzeppelin-contracts-upgradeable-4.9.6/","@openzeppelin-upgradeable/contracts/=dependencies/@openzeppelin-contracts-upgradeable-4.9.6/","@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-4.9.6/","@uniswap-v2-core-1.0.1/=dependencies/@uniswap-v2-core-1.0.1/","@uniswap-v2-periphery-1.1.0-beta.0/=dependencies/@uniswap-v2-periphery-1.1.0-beta.0/","@uniswap-v3-core-1.0.2-solc-0.8-simulate/=dependencies/@uniswap-v3-core-1.0.2-solc-0.8-simulate/contracts/","@uniswap-v3-core/=dependencies/@uniswap-v3-core-1.0.2-solc-0.8-simulate/","@uniswap-v3-periphery-1.4.4/=dependencies/@uniswap-v3-periphery-1.4.4/contracts/","@uniswap-v3-periphery/=dependencies/@uniswap-v3-periphery-1.4.4/","@uniswap/=dependencies/@uniswap-v2-periphery-1.1.0-beta.0/node_modules/@uniswap/","base64-sol/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/base64-sol/","forge-std-1.9.6/=dependencies/forge-std-1.9.6/src/","forge-std/=lib/forge-std/src/","hardhat/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/hardhat/"]}},"stdJsonOutput":{"sources":{"src/supperLucky/SupperLuckyToken.sol":{"id":6},"dependencies/@openzeppelin-contracts-4.9.6/utils/Context.sol":{"id":4},"dependencies/@openzeppelin-contracts-4.9.6/access/Ownable.sol":{"id":0},"dependencies/@openzeppelin-contracts-4.9.6/utils/math/Math.sol":{"id":5},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/ERC20.sol":{"id":1},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/IERC20.sol":{"id":2},"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/extensions/IERC20Metadata.sol":{"id":3}},"contracts":{"src/supperLucky/SupperLuckyToken.sol":{"SupperLuckyToken":{"abi":[{"type":"constructor","inputs":[{"name":"name_","type":"string","internalType":"string"},{"name":"symbol_","type":"string","internalType":"string"},{"name":"deployer","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"FeeWhiteListUpdated","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"status","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"SellTransfer","type":"event","inputs":[{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DEAD_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"_getReserves","type":"function","inputs":[{"name":"pair","type":"address","internalType":"address"}],"outputs":[{"name":"rOther","type":"uint256","internalType":"uint256"},{"name":"rThis","type":"uint256","internalType":"uint256"},{"name":"balanceOther","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"brunFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"burnCoolDownTime","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"burnPercent","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claimContract","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"feeWhiteList","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"lastBurnTime","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"miningPoolContract","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownerBurnLiquidityPairTokens","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBrunFee","type":"function","inputs":[{"name":"_brunFee","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBurnCoolDownTime","type":"function","inputs":[{"name":"_burnCoolDownTime","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBurnPercent","type":"function","inputs":[{"name":"_burnPercent","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setContractAddress","type":"function","inputs":[{"name":"_miningPoolContract","type":"address","internalType":"address"},{"name":"_claimContract","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setFeeWhiteList","type":"function","inputs":[{"name":"addr","type":"address","internalType":"address"},{"name":"enable","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMiningFee","type":"function","inputs":[{"name":"_miningFee","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRewardFee","type":"function","inputs":[{"name":"_rewardFee","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"swapRouter","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IUniswapV2Router02"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"usdtAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"usdtPair","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"FeeWhiteListUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SellTransfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEAD_WALLET\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"name\":\"_getReserves\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"rOther\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rThis\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balanceOther\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"brunFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"burnCoolDownTime\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"burnPercent\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"feeWhiteList\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastBurnTime\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"miningPoolContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ownerBurnLiquidityPairTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_brunFee\",\"type\":\"uint256\"}],\"name\":\"setBrunFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_burnCoolDownTime\",\"type\":\"uint256\"}],\"name\":\"setBurnCoolDownTime\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_burnPercent\",\"type\":\"uint256\"}],\"name\":\"setBurnPercent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_miningPoolContract\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_claimContract\",\"type\":\"address\"}],\"name\":\"setContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"enable\",\"type\":\"bool\"}],\"name\":\"setFeeWhiteList\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_miningFee\",\"type\":\"uint256\"}],\"name\":\"setMiningFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_rewardFee\",\"type\":\"uint256\"}],\"name\":\"setRewardFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"contract IUniswapV2Router02\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"usdtAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"usdtPair\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"decreaseAllowance(address,uint256)\":{\"details\":\"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.\"},\"increaseAllowance(address,uint256)\":{\"details\":\"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.\"},\"name()\":{\"details\":\"Returns the name of the token.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/supperLucky/SupperLuckyToken.sol\":\"SupperLuckyToken\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@ensdomains/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/@ensdomains/\",\":@openzeppelin-contracts-4.9.6/=dependencies/@openzeppelin-contracts-4.9.6/\",\":@openzeppelin-contracts-upgradeable-4.9.6/=dependencies/@openzeppelin-contracts-upgradeable-4.9.6/\",\":@openzeppelin-upgradeable/contracts/=dependencies/@openzeppelin-contracts-upgradeable-4.9.6/\",\":@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-4.9.6/\",\":@uniswap-v2-core-1.0.1/=dependencies/@uniswap-v2-core-1.0.1/\",\":@uniswap-v2-periphery-1.1.0-beta.0/=dependencies/@uniswap-v2-periphery-1.1.0-beta.0/\",\":@uniswap-v3-core-1.0.2-solc-0.8-simulate/=dependencies/@uniswap-v3-core-1.0.2-solc-0.8-simulate/contracts/\",\":@uniswap-v3-core/=dependencies/@uniswap-v3-core-1.0.2-solc-0.8-simulate/\",\":@uniswap-v3-periphery-1.4.4/=dependencies/@uniswap-v3-periphery-1.4.4/contracts/\",\":@uniswap-v3-periphery/=dependencies/@uniswap-v3-periphery-1.4.4/\",\":@uniswap/=dependencies/@uniswap-v2-periphery-1.1.0-beta.0/node_modules/@uniswap/\",\":base64-sol/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/base64-sol/\",\":forge-std-1.9.6/=dependencies/forge-std-1.9.6/src/\",\":forge-std/=lib/forge-std/src/\",\":hardhat/=dependencies/@uniswap-v3-periphery-1.4.4/node_modules/hardhat/\"],\"viaIR\":true},\"sources\":{\"dependencies/@openzeppelin-contracts-4.9.6/access/Ownable.sol\":{\"keccak256\":\"0xba43b97fba0d32eb4254f6a5a297b39a19a247082a02d6e69349e071e2946218\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://fc980984badf3984b6303b377711220e067722bbd6a135b24669ff5069ef9f32\",\"dweb:/ipfs/QmPHXMSXj99XjSVM21YsY6aNtLLjLVXDbyN76J5HQYvvrz\"]},\"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/ERC20.sol\":{\"keccak256\":\"0xa56ca923f70c1748830700250b19c61b70db9a683516dc5e216694a50445d99c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cac938788bc4be12101e59d45588b4e059579f4e61062e1cda8d6b06c0191b15\",\"dweb:/ipfs/QmV2JKCyjTVH3rkWNrfdJRhAT7tZ3usAN2XcnD4h53Mvih\"]},\"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5\",\"dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53\"]},\"dependencies/@openzeppelin-contracts-4.9.6/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5a376d3dda2cb70536c0a45c208b29b34ac560c4cb4f513a42079f96ba47d2dd\",\"dweb:/ipfs/QmZQg6gn1sUpM8wHzwNvSnihumUCAhxD119MpXeKp8B9s8\"]},\"dependencies/@openzeppelin-contracts-4.9.6/utils/Context.sol\":{\"keccak256\":\"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a367861093b74443b137564d3f3c472f70bcf114739e62059c939f25e315706c\",\"dweb:/ipfs/Qmd7JMpcxD9RuQjK3uM3EzJUgSqdN8vzp8eytEiuwxQJ6h\"]},\"dependencies/@openzeppelin-contracts-4.9.6/utils/math/Math.sol\":{\"keccak256\":\"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c\",\"dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS\"]},\"src/supperLucky/SupperLuckyToken.sol\":{\"keccak256\":\"0x4c397cfdb272680d3475846c568984883e7ba1fbfd6ed83b2daa7cef803afd14\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://329aca46149b3fbdbc02dfcce8500a2da8b93effd94c6b65aa79e475bab28583\",\"dweb:/ipfs/QmSAx9pc17LbRwxvk56hcwB7EL9PXVwFQHPbNijE4hrSXZ\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":128,"label":"_balances","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":134,"label":"_allowances","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"2","type":"t_uint256","astId":136,"label":"_totalSupply","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"3","type":"t_string_storage","astId":138,"label":"_name","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"4","type":"t_string_storage","astId":140,"label":"_symbol","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"5","type":"t_address","astId":7,"label":"_owner","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"6","type":"t_uint256","astId":1859,"label":"miningFee","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"7","type":"t_uint256","astId":1862,"label":"brunFee","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"8","type":"t_uint256","astId":1865,"label":"rewardFee","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"9","type":"t_address","astId":1874,"label":"miningPoolContract","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"10","type":"t_address","astId":1876,"label":"claimContract","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"11","type":"t_mapping(t_address,t_bool)","astId":1880,"label":"feeWhiteList","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"12","type":"t_uint256","astId":1883,"label":"burnCoolDownTime","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"13","type":"t_uint256","astId":1885,"label":"lastBurnTime","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"14","type":"t_uint256","astId":1888,"label":"burnPercent","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"},{"slot":"15","type":"t_bool","astId":1890,"label":"swapping","offset":0,"contract":"src/supperLucky/SupperLuckyToken.sol:SupperLuckyToken"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"2243:8010:6:-:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;2046:13:1;2243:8010:6;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;-1:-1:-1;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;2069:17:1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;955:12:0;734:10:4;955:12:0;:::i;:::-;2415:4:6;;2243:8010;2450:3;;2243:8010;2487:4;;2243:8010;2791:10;;2243:8010;2869:3;;2243:8010;-1:-1:-1;;;;;2243:8010:6;;;;;;;8603:21:1;;2243:8010:6;;;8731:22:1;2243:8010:6;3332:14;2243:8010;;;;;;;;;-1:-1:-1;8952:37:1;2243:8010:6;3376:8;2243:8010;;;;8731:22:1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;8952:37:1;3376:8:6;:::i;:::-;3400:13;3417:2;3400:19;3417:2;;3449:42;3435:56;;3554:42;3505:105;;3396:431;2243:8010;;;3892:10;2243:8010;;;;;;;;;;;3892:20;;;;;;;;;-1:-1:-1;3892:20:6;;;3396:431;2243:8010;;;;;-1:-1:-1;2243:8010:6;3965:11;2243:8010;;;;;;;;;;;;;3874:112;;3946:4;3874:112;;;2243:8010;;;;;;3874:112;;;;;;-1:-1:-1;3874:112:6;;;3396:431;-1:-1:-1;;;;;;;;;;;3863:123:6;;;;2243:8010;-1:-1:-1;2243:8010:6;6000:12;2243:8010;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;6042:33;2243:8010;;;;;;;3892:10;2243:8010;;;;;;;;;;3863:123;2243:8010;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3965:11;2243:8010;;;;;;3874:112;;;;;;;;;;;;;;;:::i;:::-;;;2243:8010;;;;;-1:-1:-1;;;;;;;;;;;2243:8010:6;;:::i;:::-;3874:112;;2243:8010;-1:-1:-1;2243:8010:6;;3874:112;;;;;;2243:8010;;;-1:-1:-1;2243:8010:6;;;;;3892:20;;;;;;;;;;;;;;;;;;:::i;:::-;;;2243:8010;;;;;;;;;:::i;:::-;3892:20;;;;;;;;;;;;2243:8010;;;-1:-1:-1;2243:8010:6;;;;;3396:431;3655:42;3641:56;;3760:42;3711:105;;3396:431;;2243:8010;;;;;;-1:-1:-1;2243:8010:6;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;2069:17:1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;:::o;2426:187:0:-;2518:6;2243:8010:6;;-1:-1:-1;;;;;2243:8010:6;;;-1:-1:-1;;;;;;2243:8010:6;;;;;;;;;;2566:40:0;-1:-1:-1;;2566:40:0;2426:187::o","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"2243:8010:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;:::i;:::-;1063:62:0;;;:::i;:::-;-1:-1:-1;;;;;2243:8010:6;;;;2162:22:0;;2243:8010:6;;;;2518:6:0;2243:8010:6;;;;;;;;2518:6:0;2243:8010:6;;2566:40:0;2243:8010:6;2566:40:0;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;2807:27;2243:8010;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2425:28;2243:8010;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;6042:33;1063:62:0;2243:8010:6;1063:62:0;;;:::i;:::-;-1:-1:-1;;;;;2243:8010:6;;;;6000:12;2243:8010;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;;;;;6042:33;2243:8010;;;;;;;;;;;;;;;;;;;;2632:33;2243:8010;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;2498:46;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4646:26;2243:8010;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4522:36;2243:8010;;;;;;;;;;;;;;;;;;2550:33;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3894:6:1;2243:8010:6;;:::i;:::-;;;734:10:4;;3894:6:1;:::i;:::-;2243:8010:6;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;734:10:4;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;6792:35:1;;;;2243:8010:6;;;;6928:34:1;2243:8010:6;;;;734:10:4;6928:34:1;:::i;2243:8010:6:-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;2339:42;2243:8010;;;;;;;;;;;;;;;;;;2589:36;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;-1:-1:-1;;;;2243:8010:6;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1273:6:0;2243:8010:6;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4756:22;2243:8010;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4858:18;2243:8010;;;;;;;;;;;;;;;;1063:62:0;;:::i;:::-;2518:6;2243:8010:6;;-1:-1:-1;;;;;;2243:8010:6;;;;;;;-1:-1:-1;;;;;2243:8010:6;2566:40:0;2243:8010:6;;2566:40:0;2243:8010:6;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2671:28;2243:8010;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;2757:44;2243:8010;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;1273:6;2243:8010:6;-1:-1:-1;;;;;2243:8010:6;6631:8;;6650:6;;2243:8010;;;;;6631:8;6650:6;:::i;:::-;2243:8010;6667:26;;;;;;2243:8010;;-1:-1:-1;;;;;;6667:26:6;;2243:8010;;;;;;;;;6667:26;;;;;;;;;;2243:8010;;;6667:26;;;;;:::i;:::-;2243:8010;6667:26;2243:8010;;;;;;;;6667:26;2243:8010;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;1063:62:0;;:::i;:::-;2243:8010:6;4960:22;2243:8010;;;;;;;;;;;;;;;;;6021:38:1;2243:8010:6;;:::i;:::-;734:10:4;2243:8010:6;;;;;;;;;;;;;;;;;;;6021:38:1;2243:8010:6;;;;;;6021:38:1;:::i;:::-;734:10:4;;6021:38:1;:::i;2243:8010:6:-;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;3186:2:1;2243:8010:6;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;734:10:4;2243:8010:6;;;;;;;;11264:17:1;;;11244:37;;11240:243;;2243:8010:6;;5424:6:1;;;;;;:::i;11240:243::-;11305:26;;;2243:8010:6;;;;;;11432:25:1;2243:8010:6;;;5424:6:1;2243:8010:6;;734:10:4;11432:25:1;;:::i;:::-;11240:243;;;;;;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;:::i;:::-;;;:::i;:::-;1063:62:0;;:::i;:::-;4344:40:6;2243:8010;;-1:-1:-1;;;;;2243:8010:6;;;-1:-1:-1;;;;;;2243:8010:6;;;;;;;4394:30;2243:8010;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;3342:12:1;2243:8010:6;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;-1:-1:-1;;;;;2243:8010:6;;:::i;:::-;;;;2706:44;2243:8010;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4606:6:1;2243:8010:6;;:::i;:::-;;;734:10:4;;4606:6:1;:::i;2243:8010:6:-;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;;2244:5:1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2244:5:1;2243:8010:6;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;-1:-1:-1;;2243:8010:6;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2243:8010:6;;;;;;2840:32;2243:8010;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;:::o;:::-;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;:::o;:::-;;;;;;;;;;-1:-1:-1;;;;;2243:8010:6;;;;;;;:::o;9248:621::-;2243:8010;;;-1:-1:-1;;;9482:22:6;;-1:-1:-1;;;;;2243:8010:6;;;;;9248:621;2243:8010;9482:22;2243:8010;9482:22;2243:8010;;9482:22;;;;;;;;;;;;;9248:621;2243:8010;-1:-1:-1;;;;;2243:8010:6;;;;;;;;;;;;9536:17;;;;;;;9482:22;9536:17;;;;;;;;;9482:22;9536:17;;;9248:621;-1:-1:-1;2243:8010:6;;9565:4;9536:34;9565:4;;-1:-1:-1;2243:8010:6;;-1:-1:-1;;;9585:17:6;;;2243:8010;9482:22;2243:8010;9585:17;;;;;;;;9482:22;9585:17;;;9536:98;;;2243:8010;;9565:4;9649:26;;9565:4;;;9691:11;;9716:10;9645:158;;2243:8010;;;;;;;;;;9828:34;;9482:22;9828:34;;2243:8010;9828:34;;;;;;;;9482:22;9828:34;;;9813:49;;9248:621;:::o;9828:34::-;;;;;;;;;;;;;;;;:::i;:::-;;;2243:8010;;;;;9248:621;:::o;9828:34::-;;;;;9645:158;9757:11;;;9645:158;;9585:17;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;2243:8010;;;9482:22;2243:8010;;;;;9536:98;2243:8010;;9617:17;;;;;9482:22;9617:17;;;;;;;;;9482:22;9617:17;;;9536:98;;;;9617:17;;;;;;;;;;;;;;:::i;:::-;;;;9536;;;;;;;;;;;;;;:::i;:::-;;;;;2243:8010;;;9482:22;2243:8010;;;;;9482:22;;;;;;;;;;;;;;;;;;:::i;:::-;;;2243:8010;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;9482:22;;;;;;-1:-1:-1;9482:22:6;;;2243:8010;;;9482:22;2243:8010;;;;;10457:340:1;-1:-1:-1;;;;;2243:8010:6;;;;10558:19:1;;2243:8010:6;;;10636:21:1;;;2243:8010:6;;;10758:32:1;2243:8010:6;;10575:1:1;2243:8010:6;10707:11:1;2243:8010:6;;;10575:1:1;2243:8010:6;;10575:1:1;2243:8010:6;;;;;10575:1:1;2243:8010:6;;;;;;;10758:32:1;10457:340::o;2243:8010:6:-;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;1359:130:0;1273:6;2243:8010:6;-1:-1:-1;;;;;2243:8010:6;734:10:4;1422:23:0;2243:8010:6;;1359:130:0:o;2243:8010:6:-;;;;;;;;;;;;;;;;;;;;;;;;;4995:908;2243:8010;;;;;;;3519:9:1;2243:8010:6;3519:9:1;2243:8010:6;;;;3519:9:1;2243:8010:6;;5122:25;2243:8010;;-1:-1:-1;;;;;2243:8010:6;;3519:9:1;2243:8010:6;;;5187:12;2243:8010;;;;;;;;5187:38;;;;4995:908;5183:122;;-1:-1:-1;;;;;2243:8010:6;;;5330:8;2243:8010;;;5322:16;2243:8010;;3519:9:1;7524:40:6;5330:8;7524:40;:::i;:::-;7574:19;3519:9:1;7607:10:6;;;:23;;;4995:908;7603:93;;4995:908;7743:20;;;;:::i;:::-;7727:36;;;7723:233;;4995:908;2243:8010;;;5463:8;2243:8010;;;;5462:9;:41;;;4995:908;5462:76;;;4995:908;5462:118;;;4995:908;5445:259;;4995:908;5718:19;;:37;;;4995:908;5714:139;;5889:6;;;;;:::i;:::-;4995:908::o;5714:139::-;6876:5;;2243:8010;6937:12;2243:8010;6854:18;6863:9;2243:8010;6854:18;;:::i;:::-;6917;2243:8010;;;;;-1:-1:-1;;;;;2243:8010:6;5330:8;6937:12;:::i;:::-;5330:8;-1:-1:-1;;;;;2243:8010:6;6960:26;;;;2243:8010;;-1:-1:-1;;;;;;6960:26:6;;2243:8010;3519:9:1;2243:8010:6;6960:26;2243:8010;3519:9:1;5330:8:6;-1:-1:-1;;;;;2243:8010:6;6960:26;;;;;;7291:34;6960:26;7291:34;6960:26;7291:21;6960:26;;;5714:139;2243:8010;7001:20;2243:8010;;;;;;7001:20;2243:8010;7055:18;7064:9;2243:8010;7055:18;;:::i;:::-;2243:8010;;7114:16;7123:7;2243:8010;7114:16;;:::i;:::-;2243:8010;7184:10;;;;;:::i;:::-;7227:13;2243:8010;7242:12;;2243:8010;;-1:-1:-1;;;;;2243:8010:6;7242:12;;:::i;:::-;7291:21;:::i;:34::-;;;:::i;6960:26::-;;;;:::i;:::-;;;;;2243:8010;;;3519:9:1;2243:8010:6;;;;;5718:37;-1:-1:-1;;;;;;2243:8010:6;;;5330:8;2243:8010;;;5741:14;5718:37;;5445:259;-1:-1:-1;;2243:8010:6;;;5616:4;2243:8010;5463:8;2243:8010;6088:440;;:::i;:::-;5463:8;2243:8010;;5463:8;2243:8010;5445:259;;;5462:118;-1:-1:-1;5562:18:6;2243:8010;-1:-1:-1;;;;;2243:8010:6;;;;;5554:26;;5462:118;;:76;5519:19;;;5462:76;;:41;-1:-1:-1;;;;;;2243:8010:6;;;5330:8;2243:8010;;;5322:16;;5462:41;;7723:233;2243:8010;;-1:-1:-1;;;8210:29:6;;3519:9:1;;-1:-1:-1;2243:8010:6;7795:150;;2243:8010;;8210:29;2243:8010;5330:8;-1:-1:-1;;;;;2243:8010:6;8210:29;;;;;;;3519:9:1;8210:29:6;;;7723:233;-1:-1:-1;2243:8010:6;;-1:-1:-1;;;8283:20:6;;8184:55;;2243:8010;;;8210:29;2243:8010;8283:10;-1:-1:-1;;;;;2243:8010:6;8283:20;;;;;;;8210:29;8283:20;2243:8010;8283:20;3519:9:1;8283:20:6;;;7723:233;-1:-1:-1;2243:8010:6;;-1:-1:-1;;;8265:47:6;;2243:8010;;;;;-1:-1:-1;;;;;2243:8010:6;8265:47;;;;;;;3519:9:1;8265:47:6;;;7723:233;-1:-1:-1;2243:8010:6;;-1:-1:-1;;;8381:23:6;;2243:8010;-1:-1:-1;;;;;2243:8010:6;;;8335:19;;;2243:8010;;;;8210:29;;2243:8010;;5330:8;2243:8010;8381:23;;;;;;;;;3519:9:1;8381:23:6;;;7723:233;-1:-1:-1;8419:20:6;;;;;;;7723:233;8415:460;;7723:233;8903:13;;;;;:::i;:::-;8930:20;;;;8970:11;;;;8966:96;;8926:310;;;;7723:233;;;;;8966:96;9013:27;9023:16;;;;;;:::i;:::-;9013:27;:::i;:::-;-1:-1:-1;;2243:8010:6;;;;;;;8966:96;;;;8926:310;9131:25;;;9180:31;9131:25;;;9181:24;9131:25;9130:32;9131:25;;;:::i;:::-;9130:32;:::i;:::-;9181:24;;;:::i;9180:31::-;672:5:5;;;;;;:13;8926:310:6;;672:13:5;;;8926:310:6;;8415:460;8481:7;;8471:18;8481:7;;8523:17;8481:7;;:::i;8471:18::-;8523:17;;:::i;:::-;8558;;;;8554:311;;8415:460;;;;;;8554:311;8634:17;;;;;8615:37;8634:17;;;;:::i;:::-;8615:37;;:::i;:::-;2243:8010;;8655:1;2243:8010;;;8655:1;2243:8010;;;;;;;;8704:1;2243:8010;;;8704:1;2243:8010;;;;;;;;;8655:1;8696:21;2243:8010;;8704:1;8752:23;2243:8010;;8696:21;:::i;:::-;2243:8010;;8752:23;:::i;:::-;8797:18;;8793:57;;8554:311;;;;;;8793:57;8903:13;8817:33;;;;;;;;:::i;:::-;8793:57;;;;;;8419:20;8428:11;;;;8419:20;;8381:23;;;;;;2243:8010;8381:23;;2243:8010;8381:23;;;;;;2243:8010;8381:23;;;:::i;:::-;;;2243:8010;;;;;;;;;;;8381:23;;;;;-1:-1:-1;8381:23:6;;8265:47;;;;2243:8010;8265:47;2243:8010;8265:47;;;;;;;:::i;:::-;;;;8283:20;;;;;;;;;;;;;;:::i;:::-;;;;8210:29;;;;2243:8010;8210:29;;2243:8010;8210:29;;;;;;2243:8010;8210:29;;;:::i;:::-;;;2243:8010;;;;;8210:29;;;;;;;-1:-1:-1;8210:29:6;;7603:93;7661:15;7743:20;7660:25;7661:15;;;;;:::i;7660:25::-;7603:93;;;;7607:23;7621:9;;;;7607:23;;2243:8010;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;5183:122;5267:6;;;;;:::i;5187:38::-;-1:-1:-1;;;;;;2243:8010:6;;3519:9:1;2243:8010:6;;;;;;;;;5187:38;;2243:8010;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;7456:788:1;-1:-1:-1;;;;;2243:8010:6;7552:18:1;;2243:8010:6;;;-1:-1:-1;2243:8010:6;-1:-1:-1;2243:8010:6;;;-1:-1:-1;2243:8010:6;;7801:21:1;;;2243:8010:6;;;;;-1:-1:-1;2243:8010:6;-1:-1:-1;2243:8010:6;;;;-1:-1:-1;2243:8010:6;;8163:26:1;2243:8010:6;2339:42;2243:8010;;-1:-1:-1;2243:8010:6;;-1:-1:-1;2243:8010:6;;;;;;;;;;;;8163:26:1;7456:788::o;2243:8010:6:-;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;7456:788:1;-1:-1:-1;;;;;2243:8010:6;;;;7552:18:1;;2243:8010:6;;;7630:16:1;;;2243:8010:6;;;7568:1:1;2243:8010:6;7568:1:1;2243:8010:6;;;7568:1:1;2243:8010:6;;7801:21:1;;;2243:8010:6;;;8163:26:1;2243:8010:6;;;;7568:1:1;2243:8010:6;7568:1:1;2243:8010:6;;;;7568:1:1;2243:8010:6;;;7568:1:1;2243:8010:6;;7568:1:1;2243:8010:6;;;;;;;;;;;;8163:26:1;7456:788::o;2243:8010:6:-;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;-1:-1:-1;;;2243:8010:6;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;2977:197;6165:16;2243:8010;3027:12;2243:8010;3027:16;;;;:57;;;;2977:197;3023:94;;;6472:12;6418:5;6398;6343:39;6232:8;6219:22;6343:19;6279:30;6219:22;;;:::i;:::-;6279:15;;;;;:30;:::i;:::-;2243:8010;6351:11;2243:8010;6343:19;;:::i;:::-;:39;:::i;:::-;2243:8010;;6472:12;;:::i;:::-;-1:-1:-1;;;;;2243:8010:6;6495:26;;;;;-1:-1:-1;2243:8010:6;;6495:26;2243:8010;;;;;;;;;6495:26;;;;;;;;;;2977:197;6279:15;;3027:12;2243:8010;2977:197::o;6495:26::-;;;;:::i;:::-;;;;3023:94;3100:7;:::o;3027:57::-;3065:19;;;;;:::i;:::-;3047:15;:37;3027:57;;;2243:8010;;;;;;;;;;:::o;6530:1642:5:-;6601:6;;6597:45;;8144:10;7344:7;6606:1;2243:8010:6;;8769:3:5;2243:8010:6;8760:16:5;8756:99;;6530:1642;2243:8010:6;;8881:2:5;2243:8010:6;8872:15:5;8868:96;;6530:1642;2243:8010:6;;8990:2:5;2243:8010:6;8981:15:5;8977:96;;6530:1642;2243:8010:6;;9099:2:5;2243:8010:6;9090:15:5;9086:96;;6530:1642;2243:8010:6;;9208:1:5;2243:8010:6;9199:14:5;9195:93;;6530:1642;2243:8010:6;;9314:1:5;2243:8010:6;9305:14:5;9301:93;;6530:1642;2243:8010:6;;9420:1:5;2243:8010:6;9411:14:5;9407:93;;6530:1642;9526:1;;2243:8010:6;;;;;;9513:64:5;;6530:1642;2243:8010:6;;7801:10:5;;;;:::i;:::-;2243:8010:6;;;7850:10:5;;;;:::i;:::-;2243:8010:6;;;7899:10:5;;;;:::i;:::-;2243:8010:6;;;7948:10:5;;;;:::i;:::-;2243:8010:6;;;7997:10:5;;;;:::i;:::-;2243:8010:6;;;8046:10:5;;;;:::i;:::-;2243:8010:6;;;8095:10:5;;;;:::i;:::-;2243:8010:6;;;8144:10:5;;;:::i;:::-;672:5;;;;;;:13;6530:1642;:::o;672:13::-;;;6530:1642;:::o;9513:64::-;2243:8010:6;9513:64:5;;;9407:93;9420:1;9445:11;;2243:8010:6;;9407:93:5;;;;9301;9314:1;9339:11;;2243:8010:6;;9301:93:5;;;;9195;9208:1;9233:11;;2243:8010:6;;9195:93:5;;;;9086:96;9099:2;9125:12;;2243:8010:6;;9086:96:5;;;;8977;8990:2;9016:12;;2243:8010:6;;8977:96:5;;;;8868;8881:2;8907:12;;2243:8010:6;;8868:96:5;;;;8756:99;8796:13;;;8769:3;8756:99;;;;6597:45;6623:8;6606:1;6623:8;:::o","linkReferences":{},"immutableReferences":{"1868":[{"start":947,"length":32},{"start":5097,"length":32}],"1870":[{"start":1083,"length":32},{"start":2131,"length":32},{"start":4285,"length":32},{"start":4330,"length":32},{"start":4498,"length":32},{"start":4536,"length":32},{"start":4607,"length":32},{"start":4829,"length":32},{"start":4948,"length":32},{"start":5016,"length":32},{"start":5243,"length":32},{"start":6555,"length":32}],"1872":[{"start":1452,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"brunFee()","signatureHash4":"0xda0a4ef2","signatureHash32":"0xda0a4ef2b0634a9e9ecfd0701e50c346cc7a014ae33f0a473eebf86a62a5a34e"},{"signature":"burnCoolDownTime()","signatureHash4":"0x56dc7319","signatureHash32":"0x56dc73194f15d237576da242fb4f4b59427e0cb70b902b2d7e484d5abbda3db4"},{"signature":"burnPercent()","signatureHash4":"0x03807ee5","signatureHash32":"0x03807ee53cae163e4884d9b08ca703ccb7f390fb3b09581ce7f8e17229d3828e"},{"signature":"claimContract()","signatureHash4":"0x66345da4","signatureHash32":"0x66345da47d98f48ae09d54b72a1a8ddbd0831e2d3fc16c0fa036708cb63ef97a"},{"signature":"DEAD_WALLET()","signatureHash4":"0xa01c3483","signatureHash32":"0xa01c3483d1b2472b70648c3e1a305507468117ab4c33a4c2c0671c1853916bc7"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"decreaseAllowance(address,uint256)","signatureHash4":"0xa457c2d7","signatureHash32":"0xa457c2d77307f80ff2f3ac810ec99eb18ae2cffee13b29c90c9324546e374be5"},{"signature":"feeWhiteList(address)","signatureHash4":"0x172979e4","signatureHash32":"0x172979e49b3f577c9a9f5bc2c4862d8393b241d43497ac10db18ee4456dff942"},{"signature":"_getReserves(address)","signatureHash4":"0xb340364f","signatureHash32":"0xb340364fb1028749d122c0c03df157ba522a3803a3d86e1a551dea54970e3c85"},{"signature":"increaseAllowance(address,uint256)","signatureHash4":"0x39509351","signatureHash32":"0x39509351d3325647dde3fdd3c8b249adfe89ef4f16d76d83768e6df7a5cd81d6"},{"signature":"lastBurnTime()","signatureHash4":"0xe3067449","signatureHash32":"0xe30674498d8573f092568640faaac069ac6041cb8db555b19f50073e3c6e7601"},{"signature":"miningPoolContract()","signatureHash4":"0xceb807a7","signatureHash32":"0xceb807a7072b4f8fbabff064604dd1fef9fe62fd3a90a7d38f354905bfce4b30"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"ownerBurnLiquidityPairTokens(uint256)","signatureHash4":"0x4eb9b26d","signatureHash32":"0x4eb9b26da44556245226af5969763ba43d90ffeed9b5a7e3d9b673a439331eaa"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"setBrunFee(uint256)","signatureHash4":"0x7a5185b7","signatureHash32":"0x7a5185b73f4b0eb6e1404bd17663a5c647f19f4b87c339766eb7db391ee75ab0"},{"signature":"setBurnCoolDownTime(uint256)","signatureHash4":"0xb7bac579","signatureHash32":"0xb7bac5799111c6e05dfa23f1059ce77f59c99e9c8e7e534a59bb5f97ebca6556"},{"signature":"setBurnPercent(uint256)","signatureHash4":"0xbb1570da","signatureHash32":"0xbb1570da558963b5c9fe86646aea416ca3aa82659f8b17c71c7132ae0674355f"},{"signature":"setContractAddress(address,address)","signatureHash4":"0x23626df7","signatureHash32":"0x23626df758ed344d122c0c245e1c9848ee7c8dc6a805bc362cc7c5aa803d3642"},{"signature":"setFeeWhiteList(address,bool)","signatureHash4":"0xd83d4143","signatureHash32":"0xd83d4143bb64bbe3965c02aa6828616b7eecaaf2ccf54783cfaceac30da7f85e"},{"signature":"setMiningFee(uint256)","signatureHash4":"0x7eddab54","signatureHash32":"0x7eddab5491b580701e71c18e6095dfdbb8800b6b6fa115f756dc4138027d14e6"},{"signature":"setRewardFee(uint256)","signatureHash4":"0x41a2ac70","signatureHash32":"0x41a2ac7053ec2dc3caf4eb7835ba9cbf8a4f20c9433bdbfccdd5443792c1b0ff"},{"signature":"swapRouter()","signatureHash4":"0xc31c9c07","signatureHash32":"0xc31c9c070e1dc49250a2d97518cf28aa4e62324b428cd7d1327fd3c88a492f4c"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"usdtAddress()","signatureHash4":"0x9ab4a445","signatureHash32":"0x9ab4a4450fa297f34b9793ff68e6ab2d308e4d7736e987419d9d6cff19eabcb1"},{"signature":"usdtPair()","signatureHash4":"0xb7352a19","signatureHash32":"0xb7352a19da55826bf678284aab0842ef00ccbfaaaab9540e2b937a6519ceff64"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"FeeWhiteListUpdated(address,bool)","signatureHash4":"0xeafc0d35","signatureHash32":"0xeafc0d355d7b7a7d30b5ab1c2a43600626ad786d167f6bc97823eb50fa1df748"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"SellTransfer(uint256)","signatureHash4":"0xb01e5788","signatureHash32":"0xb01e5788449b89e730c08c951b01e9d8a7b29b698685b6a0c13096c472e9ac1d"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0xeCBDc0B76142740Bb564B8aA1BCd061Cb151a666"}