{"matchId":"56938781","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-10-25T09:08:22Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"680:4715:13:-:0;;;1275:34;;;-1:-1:-1;;1275:34:13;;;;;1794:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1961:6;1929:5;1936:7;1447:5:2;:13;1929:5:13;1447::2;:13;:::i;:::-;-1:-1:-1;1470:7:2;:17;1480:7;1470;:17;:::i;:::-;-1:-1:-1;;;;;;;;1273:26:0;;1269:95;;1322:31;;-1:-1:-1;;;1322:31:0;;1350:1;1322:31;;;4899:51:14;4872:18;;1322:31:0;;;;;;;1269:95;1373:32;1392:12;1373:18;:32::i;:::-;-1:-1:-1;1713:1:7;1917:7;:21;1983:13:13::2;:24;1999:8:::0;1983:13;:24:::2;:::i;:::-;-1:-1:-1::0;;2017:5:13::2;:14:::0;;-1:-1:-1;;;;;2017:14:13;;::::2;::::0;::::2;-1:-1:-1::0;;;;;;2017:14:13;;::::2;::::0;;;::::2;::::0;;-1:-1:-1;680:4715:13;;-1:-1:-1;;680:4715:13;2912:187:0;3004:6;;;-1:-1:-1;;;;;3020:17:0;;;-1:-1:-1;;;;;;3020:17:0;;;;;;;3052:40;;3004:6;;;3020:17;3004:6;;3052:40;;2985:16;;3052:40;2975:124;2912:187;:::o;14:127:14:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:844;200:5;253:3;246:4;238:6;234:17;230:27;220:55;;271:1;268;261:12;220:55;294:13;;-1:-1:-1;;;;;356:10:14;;;353:36;;;369:18;;:::i;:::-;444:2;438:9;412:2;498:13;;-1:-1:-1;;494:22:14;;;518:2;490:31;486:40;474:53;;;542:18;;;562:22;;;539:46;536:72;;;588:18;;:::i;:::-;628:10;624:2;617:22;663:2;655:6;648:18;685:4;675:14;;732:3;725:4;720:2;712:6;708:15;704:26;701:35;698:55;;;749:1;746;739:12;698:55;771:1;762:10;;781:133;795:2;792:1;789:9;781:133;;;883:14;;;879:23;;873:30;852:14;;;848:23;;841:63;806:10;;;;781:133;;;958:1;951:4;946:2;938:6;934:15;930:26;923:37;978:6;969:15;;;;;;146:844;;;;:::o;995:139::-;-1:-1:-1;;;;;1078:31:14;;1068:42;;1058:70;;1124:1;1121;1114:12;1058:70;995:139;:::o;1139:1054::-;1283:6;1291;1299;1307;1315;1368:3;1356:9;1347:7;1343:23;1339:33;1336:53;;;1385:1;1382;1375:12;1336:53;1412:16;;-1:-1:-1;;;;;1477:14:14;;;1474:34;;;1504:1;1501;1494:12;1474:34;1527:61;1580:7;1571:6;1560:9;1556:22;1527:61;:::i;:::-;1517:71;;1634:2;1623:9;1619:18;1613:25;1597:41;;1663:2;1653:8;1650:16;1647:36;;;1679:1;1676;1669:12;1647:36;1702:63;1757:7;1746:8;1735:9;1731:24;1702:63;:::i;:::-;1692:73;;1811:2;1800:9;1796:18;1790:25;1774:41;;1840:2;1830:8;1827:16;1824:36;;;1856:1;1853;1846:12;1824:36;;1879:63;1934:7;1923:8;1912:9;1908:24;1879:63;:::i;:::-;1869:73;;;1985:2;1974:9;1970:18;1964:25;1998:39;2031:5;1998:39;:::i;:::-;2106:3;2091:19;;2085:26;2056:5;;-1:-1:-1;2120:41:14;2085:26;2120:41;:::i;:::-;2180:7;2170:17;;;1139:1054;;;;;;;;:::o;2198:380::-;2277:1;2273:12;;;;2320;;;2341:61;;2395:4;2387:6;2383:17;2373:27;;2341:61;2448:2;2440:6;2437:14;2417:18;2414:38;2411:161;;2494:10;2489:3;2485:20;2482:1;2475:31;2529:4;2526:1;2519:15;2557:4;2554:1;2547:15;2411:161;;2198:380;;;:::o;2709:518::-;2811:2;2806:3;2803:11;2800:421;;;2847:5;2844:1;2837:16;2891:4;2888:1;2878:18;2961:2;2949:10;2945:19;2942:1;2938:27;2932:4;2928:38;2997:4;2985:10;2982:20;2979:47;;;-1:-1:-1;3020:4:14;2979:47;3075:2;3070:3;3066:12;3063:1;3059:20;3053:4;3049:31;3039:41;;3130:81;3148:2;3141:5;3138:13;3130:81;;;3207:1;3193:16;;3174:1;3163:13;3130:81;;;3134:3;;2800:421;2709:518;;;:::o;3403:1345::-;3523:10;;-1:-1:-1;;;;;3545:30:14;;3542:56;;;3578:18;;:::i;:::-;3607:97;3697:6;3657:38;3689:4;3683:11;3657:38;:::i;:::-;3651:4;3607:97;:::i;:::-;3759:4;;3816:2;3805:14;;3833:1;3828:663;;;;4535:1;4552:6;4549:89;;;-1:-1:-1;4604:19:14;;;4598:26;4549:89;-1:-1:-1;;3360:1:14;3356:11;;;3352:24;3348:29;3338:40;3384:1;3380:11;;;3335:57;4651:81;;3798:944;;3828:663;2656:1;2649:14;;;2693:4;2680:18;;-1:-1:-1;;3864:20:14;;;3982:236;3996:7;3993:1;3990:14;3982:236;;;4085:19;;;4079:26;4064:42;;4177:27;;;;4145:1;4133:14;;;;4012:19;;3982:236;;;3986:3;4246:6;4237:7;4234:19;4231:201;;;4307:19;;;4301:26;-1:-1:-1;;4390:1:14;4386:14;;;4402:3;4382:24;4378:37;4374:42;4359:58;4344:74;;4231:201;;;4478:1;4469:6;4466:1;4462:14;4458:22;4452:4;4445:36;3798:944;;;;;3403:1345;;:::o;4753:203::-;680:4715:13;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122042821153380876681387cacd8ca2622da83aac176a0f54daeb17b5dc7f48f96d64736f6c63430008180033","offset":8753}},"transformations":[{"type":"insert","offset":8806,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000b7c7a171d4385c7b4e308d81605b764ce88f0ed0000000000000000000000000b7c7a171d4385c7b4e308d81605b764ce88f0ed0000000000000000000000000000000000000000000000000000000000000007426f746d6f6c74000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007424f544d4f4c54000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"0x60806040526004361061021d575f3560e01c806370a082311161011e578063ae90b213116100a8578063cd90e5af1161006d578063cd90e5af1461062e578063e905182a14610642578063e985e9c514610669578063f2fde38b14610688578063f8004d31146106a7575f80fd5b8063ae90b21314610585578063b88d4fde146105aa578063c2178267146105c9578063c87b56dd146105f0578063c9c64ddb1461060f575f80fd5b80638f79306e116100ee5780638f79306e146104f657806395d89b411461052a578063a0712d681461053e578063a22cb46514610551578063a2309ff814610570575f80fd5b806370a0823114610487578063715018a6146104a65780638ada6b0f146104ba5780638da5cb5b146104d9575f80fd5b806332cb6b0c116101aa5780634eab3ef21161016f5780634eab3ef2146103f757806355f804b31461041657806356d3163d14610435578063599e8bb5146104545780636352211e14610468575f80fd5b806332cb6b0c1461035a5780633cef28d21461036f578063410459ad1461039a57806342842e0e146103b9578063484b973c146103d8575f80fd5b80630f2cdd6c116101f05780630f2cdd6c146102ce57806323b872dd146102f057806324bbd0491461030f5780632b7da1ec1461032857806332b5ea5014610346575f80fd5b806301ffc9a71461022157806306fdde0314610255578063081812fc14610276578063095ea7b3146102ad575b5f80fd5b34801561022c575f80fd5b5061024061023b3660046117ae565b6106c6565b60405190151581526020015b60405180910390f35b348015610260575f80fd5b50610269610717565b60405161024c9190611816565b348015610281575f80fd5b50610295610290366004611828565b6107a6565b6040516001600160a01b03909116815260200161024c565b3480156102b8575f80fd5b506102cc6102c7366004611853565b6107cd565b005b3480156102d9575f80fd5b506102e2600a81565b60405190815260200161024c565b3480156102fb575f80fd5b506102cc61030a36600461187d565b6107dc565b34801561031a575f80fd5b506009546102409060ff1681565b348015610333575f80fd5b5060095461024090610100900460ff1681565b348015610351575f80fd5b506102e261086a565b348015610365575f80fd5b506102e261271081565b34801561037a575f80fd5b506102e26103893660046118bb565b600c6020525f908152604090205481565b3480156103a5575f80fd5b506102cc6103b43660046118bb565b610946565b3480156103c4575f80fd5b506102cc6103d336600461187d565b610978565b3480156103e3575f80fd5b506102cc6103f2366004611853565b610997565b348015610402575f80fd5b506102406104113660046118bb565b610a1d565b348015610421575f80fd5b506102cc6104303660046118d6565b610aa2565b348015610440575f80fd5b506102cc61044f3660046118bb565b610ab7565b34801561045f575f80fd5b506102e2601e81565b348015610473575f80fd5b50610295610482366004611828565b610ae1565b348015610492575f80fd5b506102e26104a13660046118bb565b610aeb565b3480156104b1575f80fd5b506102cc610b30565b3480156104c5575f80fd5b50600b54610295906001600160a01b031681565b3480156104e4575f80fd5b506006546001600160a01b0316610295565b348015610501575f80fd5b50610515610510366004611853565b610b43565b6040805192835260208301919091520161024c565b348015610535575f80fd5b50610269610bbe565b6102cc61054c366004611828565b610bcd565b34801561055c575f80fd5b506102cc61056b366004611956565b610df5565b34801561057b575f80fd5b506102e260085481565b348015610590575f80fd5b50600954610295906201000090046001600160a01b031681565b3480156105b5575f80fd5b506102cc6105c43660046119f5565b610e00565b3480156105d4575f80fd5b50610295730567f2323251f0aab15c8dfb1967e4e8a7d42aee81565b3480156105fb575f80fd5b5061026961060a366004611828565b610e17565b34801561061a575f80fd5b506102cc610629366004611a9d565b610eab565b348015610639575f80fd5b506102e2600181565b34801561064d575f80fd5b506102957360b9262456de011f7d15a54cdd8c48baaa8b022f81565b348015610674575f80fd5b50610240610683366004611ab6565b610ecd565b348015610693575f80fd5b506102cc6106a23660046118bb565b610efa565b3480156106b2575f80fd5b506102cc6106c1366004611a9d565b610f34565b5f6001600160e01b031982166380ac58cd60e01b14806106f657506001600160e01b03198216635b5e139f60e01b145b8061071157506301ffc9a760e01b6001600160e01b03198316145b92915050565b60605f805461072590611aed565b80601f016020809104026020016040519081016040528092919081815260200182805461075190611aed565b801561079c5780601f106107735761010080835404028352916020019161079c565b820191905f5260205f20905b81548152906001019060200180831161077f57829003601f168201915b5050505050905090565b5f6107b082610f4f565b505f828152600460205260409020546001600160a01b0316610711565b6107d8828233610f87565b5050565b6001600160a01b03821661080a57604051633250574960e11b81525f60048201526024015b60405180910390fd5b5f610816838333610f94565b9050836001600160a01b0316816001600160a01b031614610864576040516364283d7b60e01b81526001600160a01b0380861660048301526024820184905282166044820152606401610801565b50505050565b5f805f730567f2323251f0aab15c8dfb1967e4e8a7d42aee6001600160a01b031663feaf968c6040518163ffffffff1660e01b815260040160a060405180830381865afa1580156108bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906108e19190611b3e565b509350509250505f821315806109015750610e106108ff8242611b9e565b115b1561091f57604051630cd5fa0760e11b815260040160405180910390fd5b81610935601e69d3c21bcecceda1000000611bb1565b61093f9190611bc8565b9250505090565b61094e611086565b600980546001600160a01b03909216620100000262010000600160b01b0319909216919091179055565b61099283838360405180602001604052805f815250610e00565b505050565b61099f611086565b612710816008546109b09190611be7565b11156109cf576040516352df9fe560e01b815260040160405180910390fd5b5f60085460016109df9190611be7565b90508160085f8282546109f29190611be7565b909155505f90505b8281101561086457610a1584610a108385611be7565b6110b3565b6001016109fa565b6040516370a0823160e01b81526001600160a01b03821660048201525f9081907360b9262456de011f7d15a54cdd8c48baaa8b022f906370a0823190602401602060405180830381865afa158015610a77573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a9b9190611bfa565b1192915050565b610aaa611086565b600a610992828483611c55565b610abf611086565b600b80546001600160a01b0319166001600160a01b0392909216919091179055565b5f61071182610f4f565b5f6001600160a01b038216610b15576040516322718ad960e21b81525f6004820152602401610801565b506001600160a01b03165f9081526003602052604090205490565b610b38611086565b610b415f6110cc565b565b6001600160a01b0382165f908152600c60205260408120548190816001821015610b7757610b72826001611b9e565b610b79565b5f5b9050808511610b88575f610b92565b610b928186611b9e565b92508215610bb157610ba261086a565b610bac9084611bb1565b610bb3565b5f5b935050509250929050565b60606001805461072590611aed565b610bd561111d565b60095460ff16610bf85760405163589ed34b60e01b815260040160405180910390fd5b600954610100900460ff168015610c155750610c1333610a1d565b155b15610c335760405163f947691f60e01b815260040160405180910390fd5b801580610c405750600a81115b15610c5e57604051631111cb1560e31b815260040160405180910390fd5b335f908152600c6020526040902054600a90610c7b908390611be7565b1115610c9a5760405163b92612ed60e01b815260040160405180910390fd5b61271081600854610cab9190611be7565b1115610cca576040516352df9fe560e01b815260040160405180910390fd5b5f610cd53383610b43565b50905080341015610cf95760405163949ce24160e01b815260040160405180910390fd5b335f908152600c602052604081208054849290610d17908490611be7565b90915550506008545f90610d2c906001611be7565b90508260085f828254610d3f9190611be7565b909155505f90505b83811015610d6557610d5d33610a108385611be7565b600101610d47565b508115610d8857600954610d88906201000090046001600160a01b031683611147565b81341115610da357610da333610d9e8434611b9e565b611147565b604080518281526020810185905290810183905233907f5a3358a3d27a5373c0df2604662088d37894d56b7cfd27f315770440f4e0d9199060600160405180910390a25050610df26001600755565b50565b6107d83383836111b7565b610e0b8484846107dc565b61086484848484611255565b600b546060906001600160a01b031615610ea257610e3482610f4f565b50600b5460405163c87b56dd60e01b8152600481018490526001600160a01b039091169063c87b56dd906024015f60405180830381865afa158015610e7b573d5f803e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526107119190810190611d0f565b6107118261137b565b610eb3611086565b600980549115156101000261ff0019909216919091179055565b6001600160a01b039182165f90815260056020908152604080832093909416825291909152205460ff1690565b610f02611086565b6001600160a01b038116610f2b57604051631e4fbdf760e01b81525f6004820152602401610801565b610df2816110cc565b610f3c611086565b6009805460ff1916911515919091179055565b5f818152600260205260408120546001600160a01b03168061071157604051637e27328960e01b815260048101849052602401610801565b61099283838360016113e0565b5f828152600260205260408120546001600160a01b0390811690831615610fc057610fc08184866114e4565b6001600160a01b03811615610ffa57610fdb5f855f806113e0565b6001600160a01b0381165f90815260036020526040902080545f190190555b6001600160a01b03851615611028576001600160a01b0385165f908152600360205260409020805460010190555b5f8481526002602052604080822080546001600160a01b0319166001600160a01b0389811691821790925591518793918516917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4949350505050565b6006546001600160a01b03163314610b415760405163118cdaa760e01b8152336004820152602401610801565b6107d8828260405180602001604052805f815250611548565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b60026007540361114057604051633ee5aeb560e01b815260040160405180910390fd5b6002600755565b5f826001600160a01b0316826040515f6040518083038185875af1925050503d805f8114611190576040519150601f19603f3d011682016040523d82523d5f602084013e611195565b606091505b50509050806109925760405163197121f560e01b815260040160405180910390fd5b6001600160a01b0382166111e957604051630b61174360e31b81526001600160a01b0383166004820152602401610801565b6001600160a01b038381165f81815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6001600160a01b0383163b1561086457604051630a85bd0160e11b81526001600160a01b0384169063150b7a0290611297903390889087908790600401611d81565b6020604051808303815f875af19250505080156112d1575060408051601f3d908101601f191682019092526112ce91810190611dbd565b60015b611338573d8080156112fe576040519150601f19603f3d011682016040523d82523d5f602084013e611303565b606091505b5080515f0361133057604051633250574960e11b81526001600160a01b0385166004820152602401610801565b805181602001fd5b6001600160e01b03198116630a85bd0160e11b1461137457604051633250574960e11b81526001600160a01b0385166004820152602401610801565b5050505050565b606061138682610f4f565b505f61139061155e565b90505f8151116113ae5760405180602001604052805f8152506113d9565b806113b88461156d565b6040516020016113c9929190611dd8565b6040516020818303038152906040525b9392505050565b80806113f457506001600160a01b03821615155b156114b5575f61140384610f4f565b90506001600160a01b0383161580159061142f5750826001600160a01b0316816001600160a01b031614155b801561144257506114408184610ecd565b155b1561146b5760405163a9fbf51f60e01b81526001600160a01b0384166004820152602401610801565b81156114b35783856001600160a01b0316826001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45b505b50505f90815260046020526040902080546001600160a01b0319166001600160a01b0392909216919091179055565b6114ef8383836115fd565b610992576001600160a01b03831661151d57604051637e27328960e01b815260048101829052602401610801565b60405163177e802f60e01b81526001600160a01b038316600482015260248101829052604401610801565b6115528383611661565b6109925f848484611255565b6060600a805461072590611aed565b60605f611579836116c2565b60010190505f8167ffffffffffffffff81111561159857611598611989565b6040519080825280601f01601f1916602001820160405280156115c2576020820181803683370190505b5090508181016020015b5f19016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a85049450846115cc57509392505050565b5f6001600160a01b038316158015906116595750826001600160a01b0316846001600160a01b0316148061163657506116368484610ecd565b8061165957505f828152600460205260409020546001600160a01b038481169116145b949350505050565b6001600160a01b03821661168a57604051633250574960e11b81525f6004820152602401610801565b5f61169683835f610f94565b90506001600160a01b03811615610992576040516339e3563760e11b81525f6004820152602401610801565b5f8072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b83106117005772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef8100000000831061172c576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc10000831061174a57662386f26fc10000830492506010015b6305f5e1008310611762576305f5e100830492506008015b612710831061177657612710830492506004015b60648310611788576064830492506002015b600a83106107115760010192915050565b6001600160e01b031981168114610df2575f80fd5b5f602082840312156117be575f80fd5b81356113d981611799565b5f5b838110156117e35781810151838201526020016117cb565b50505f910152565b5f81518084526118028160208601602086016117c9565b601f01601f19169290920160200192915050565b602081525f6113d960208301846117eb565b5f60208284031215611838575f80fd5b5035919050565b6001600160a01b0381168114610df2575f80fd5b5f8060408385031215611864575f80fd5b823561186f8161183f565b946020939093013593505050565b5f805f6060848603121561188f575f80fd5b833561189a8161183f565b925060208401356118aa8161183f565b929592945050506040919091013590565b5f602082840312156118cb575f80fd5b81356113d98161183f565b5f80602083850312156118e7575f80fd5b823567ffffffffffffffff808211156118fe575f80fd5b818501915085601f830112611911575f80fd5b81358181111561191f575f80fd5b866020828501011115611930575f80fd5b60209290920196919550909350505050565b80358015158114611951575f80fd5b919050565b5f8060408385031215611967575f80fd5b82356119728161183f565b915061198060208401611942565b90509250929050565b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f1916810167ffffffffffffffff811182821017156119c6576119c6611989565b604052919050565b5f67ffffffffffffffff8211156119e7576119e7611989565b50601f01601f191660200190565b5f805f8060808587031215611a08575f80fd5b8435611a138161183f565b93506020850135611a238161183f565b925060408501359150606085013567ffffffffffffffff811115611a45575f80fd5b8501601f81018713611a55575f80fd5b8035611a68611a63826119ce565b61199d565b818152886020838501011115611a7c575f80fd5b816020840160208301375f6020838301015280935050505092959194509250565b5f60208284031215611aad575f80fd5b6113d982611942565b5f8060408385031215611ac7575f80fd5b8235611ad28161183f565b91506020830135611ae28161183f565b809150509250929050565b600181811c90821680611b0157607f821691505b602082108103611b1f57634e487b7160e01b5f52602260045260245ffd5b50919050565b805169ffffffffffffffffffff81168114611951575f80fd5b5f805f805f60a08688031215611b52575f80fd5b611b5b86611b25565b9450602086015193506040860151925060608601519150611b7e60808701611b25565b90509295509295909350565b634e487b7160e01b5f52601160045260245ffd5b8181038181111561071157610711611b8a565b808202811582820484141761071157610711611b8a565b5f82611be257634e487b7160e01b5f52601260045260245ffd5b500490565b8082018082111561071157610711611b8a565b5f60208284031215611c0a575f80fd5b5051919050565b601f82111561099257805f5260205f20601f840160051c81016020851015611c365750805b601f840160051c820191505b81811015611374575f8155600101611c42565b67ffffffffffffffff831115611c6d57611c6d611989565b611c8183611c7b8354611aed565b83611c11565b5f601f841160018114611cb2575f8515611c9b5750838201355b5f19600387901b1c1916600186901b178355611374565b5f83815260208120601f198716915b82811015611ce15786850135825560209485019460019092019101611cc1565b5086821015611cfd575f1960f88860031b161c19848701351681555b505060018560011b0183555050505050565b5f60208284031215611d1f575f80fd5b815167ffffffffffffffff811115611d35575f80fd5b8201601f81018413611d45575f80fd5b8051611d53611a63826119ce565b818152856020838501011115611d67575f80fd5b611d788260208301602086016117c9565b95945050505050565b6001600160a01b03858116825284166020820152604081018390526080606082018190525f90611db3908301846117eb565b9695505050505050565b5f60208284031215611dcd575f80fd5b81516113d981611799565b5f8351611de98184602088016117c9565b835190830190611dfd8183602088016117c9565b0194935050505056fea264697066735822122042821153380876681387cacd8ca2622da83aac176a0f54daeb17b5dc7f48f96d64736f6c63430008180033","sourceMap":"680:4715:13:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1561:300:2;;;;;;;;;;-1:-1:-1;1561:300:2;;;;;:::i;:::-;;:::i;:::-;;;565:14:14;;558:22;540:41;;528:2;513:18;1561:300:2;;;;;;;;2365:89;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3497:154::-;;;;;;;;;;-1:-1:-1;3497:154:2;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:14;;;1679:51;;1667:2;1652:18;3497:154:2;1533:203:14;3323:113:2;;;;;;;;;;-1:-1:-1;3323:113:2;;;;;:::i;:::-;;:::i;:::-;;790:43:13;;;;;;;;;;;;831:2;790:43;;;;;2343:25:14;;;2331:2;2316:18;790:43:13;2197:177:14;4143:578:2;;;;;;;;;;-1:-1:-1;4143:578:2;;;;;:::i;:::-;;:::i;1249:20:13:-;;;;;;;;;;-1:-1:-1;1249:20:13;;;;;;;;1275:34;;;;;;;;;;-1:-1:-1;1275:34:13;;;;;;;;;;;2268:330;;;;;;;;;;;;;:::i;741:43::-;;;;;;;;;;;;778:6;741:43;;1466;;;;;;;;;;-1:-1:-1;1466:43:13;;;;;:::i;:::-;;;;;;;;;;;;;;4241:70;;;;;;;;;;-1:-1:-1;4241:70:13;;;;;:::i;:::-;;:::i;4787:132:2:-;;;;;;;;;;-1:-1:-1;4787:132:2;;;;;:::i;:::-;;:::i;4558:285:13:-;;;;;;;;;;-1:-1:-1;4558:285:13;;;;;:::i;:::-;;:::i;2080:115::-;;;;;;;;;;-1:-1:-1;2080:115:13;;;;;:::i;:::-;;:::i;4389:84::-;;;;;;;;;;-1:-1:-1;4389:84:13;;;;;:::i;:::-;;:::i;4316:68::-;;;;;;;;;;-1:-1:-1;4316:68:13;;;;;:::i;:::-;;:::i;888:44::-;;;;;;;;;;;;930:2;888:44;;2185:118:2;;;;;;;;;;-1:-1:-1;2185:118:2;;;;;:::i;:::-;;:::i;1920:208::-;;;;;;;;;;-1:-1:-1;1920:208:2;;;;;:::i;:::-;;:::i;2293:101:0:-;;;;;;;;;;;;;:::i;1383:23:13:-;;;;;;;;;;-1:-1:-1;1383:23:13;;;;-1:-1:-1;;;;;1383:23:13;;;1638:85:0;;;;;;;;;;-1:-1:-1;1710:6:0;;-1:-1:-1;;;;;1710:6:0;1638:85;;2694:358:13;;;;;;;;;;-1:-1:-1;2694:358:13;;;;;:::i;:::-;;:::i;:::-;;;;4123:25:14;;;4179:2;4164:18;;4157:34;;;;4096:18;2694:358:13;3949:248:14;2518:93:2;;;;;;;;;;;;;:::i;3093:932:13:-;;;;;;:::i;:::-;;:::i;3718:144:2:-;;;;;;;;;;-1:-1:-1;3718:144:2;;;;;:::i;:::-;;:::i;1217:26:13:-;;;;;;;;;;;;;;;;1315:28;;;;;;;;;;-1:-1:-1;1315:28:13;;;;;;;-1:-1:-1;;;;;1315:28:13;;;4985:208:2;;;;;;;;;;-1:-1:-1;4985:208:2;;;;;:::i;:::-;;:::i;973:97:13:-;;;;;;;;;;;;1027:42;973:97;;4888:249;;;;;;;;;;-1:-1:-1;4888:249:13;;;;;:::i;:::-;;:::i;4143:93::-;;;;;;;;;;-1:-1:-1;4143:93:13;;;;;:::i;:::-;;:::i;839:43::-;;;;;;;;;;;;881:1;839:43;;1109:77;;;;;;;;;;;;1144:42;1109:77;;3928:153:2;;;;;;;;;;-1:-1:-1;3928:153:2;;;;;:::i;:::-;;:::i;2543:215:0:-;;;;;;;;;;-1:-1:-1;2543:215:0;;;;;:::i;:::-;;:::i;4067:71:13:-;;;;;;;;;;-1:-1:-1;4067:71:13;;;;;:::i;:::-;;:::i;1561:300:2:-;1663:4;-1:-1:-1;;;;;;1698:40:2;;-1:-1:-1;;;1698:40:2;;:104;;-1:-1:-1;;;;;;;1754:48:2;;-1:-1:-1;;;1754:48:2;1698:104;:156;;;-1:-1:-1;;;;;;;;;;861:40:9;;;1818:36:2;1679:175;1561:300;-1:-1:-1;;1561:300:2:o;2365:89::-;2410:13;2442:5;2435:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2365:89;:::o;3497:154::-;3564:7;3583:22;3597:7;3583:13;:22::i;:::-;-1:-1:-1;6008:7:2;6034:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6034:24:2;3623:21;5938:127;3323:113;3394:35;3403:2;3407:7;735:10:6;3394:8:2;:35::i;:::-;3323:113;;:::o;4143:578::-;-1:-1:-1;;;;;4237:16:2;;4233:87;;4276:33;;-1:-1:-1;;;4276:33:2;;4306:1;4276:33;;;1679:51:14;1652:18;;4276:33:2;;;;;;;;4233:87;4538:21;4562:34;4570:2;4574:7;735:10:6;4562:7:2;:34::i;:::-;4538:58;;4627:4;-1:-1:-1;;;;;4610:21:2;:13;-1:-1:-1;;;;;4610:21:2;;4606:109;;4654:50;;-1:-1:-1;;;4654:50:2;;-1:-1:-1;;;;;7986:15:14;;;4654:50:2;;;7968:34:14;8018:18;;;8011:34;;;8081:15;;8061:18;;;8054:43;7903:18;;4654:50:2;7728:375:14;4606:109:2;4223:498;4143:578;;;:::o;2268:330:13:-;2313:7;2335:13;2351:17;1027:42;-1:-1:-1;;;;;2373:23:13;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2332:66;;;;;;;2422:1;2412:6;:11;;:52;;;-1:-1:-1;2457:7:13;2427:27;2445:9;2427:15;:27;:::i;:::-;:37;2412:52;2408:77;;;2473:12;;-1:-1:-1;;;2473:12:13;;;;;;;;;;;2408:77;2584:6;2550:22;930:2;2568:4;2550:22;:::i;:::-;2549:42;;;;:::i;:::-;2542:49;;;;2268:330;:::o;4241:70::-;1531:13:0;:11;:13::i;:::-;4299:5:13::1;:9:::0;;-1:-1:-1;;;;;4299:9:13;;::::1;::::0;::::1;-1:-1:-1::0;;;;;;4299:9:13;;::::1;::::0;;;::::1;::::0;;4241:70::o;4787:132:2:-;4873:39;4890:4;4896:2;4900:7;4873:39;;;;;;;;;;;;:16;:39::i;:::-;4787:132;;;:::o;4558:285:13:-;1531:13:0;:11;:13::i;:::-;778:6:13::1;4654:8;4640:11;;:22;;;;:::i;:::-;:35;4636:57;;;4684:9;;-1:-1:-1::0;;;4684:9:13::1;;;;;;;;;;;4636:57;4703:13;4719:11;;4733:1;4719:15;;;;:::i;:::-;4703:31;;4759:8;4744:11;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;4782:9:13::1;::::0;-1:-1:-1;4777:59:13::1;4797:8;4793:1;:12;4777:59;;;4812:24;4822:2:::0;4826:9:::1;4834:1:::0;4826:5;:9:::1;:::i;:::-;4812;:24::i;:::-;4807:3;;4777:59;;2080:115:::0;2155:29;;-1:-1:-1;;;2155:29:13;;-1:-1:-1;;;;;1697:32:14;;2155:29:13;;;1679:51:14;2132:4:13;;;;1144:42;;2155:26;;1652:18:14;;2155:29:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;;2080:115;-1:-1:-1;;2080:115:13:o;4389:84::-;1531:13:0;:11;:13::i;:::-;4451::13::1;:19;4467:3:::0;;4451:13;:19:::1;:::i;4316:68::-:0;1531:13:0;:11;:13::i;:::-;4369:8:13::1;:12:::0;;-1:-1:-1;;;;;;4369:12:13::1;-1:-1:-1::0;;;;;4369:12:13;;;::::1;::::0;;;::::1;::::0;;4316:68::o;2185:118:2:-;2248:7;2274:22;2288:7;2274:13;:22::i;1920:208::-;1983:7;-1:-1:-1;;;;;2006:19:2;;2002:87;;2048:30;;-1:-1:-1;;;2048:30:2;;2075:1;2048:30;;;1679:51:14;1652:18;;2048:30:2;1533:203:14;2002:87:2;-1:-1:-1;;;;;;2105:16:2;;;;;:9;:16;;;;;;;1920:208::o;2293:101:0:-;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;2694:358:13:-;-1:-1:-1;;;;;2823:16:13;;2764:15;2823:16;;;:8;:16;;;;;;2764:15;;;881:1;2868:26;;;:58;;2901:25;2919:7;881:1;2901:25;:::i;:::-;2868:58;;;2897:1;2868:58;2849:77;;2954:8;2943;:19;:45;;2987:1;2943:45;;;2965:19;2976:8;2965;:19;:::i;:::-;2936:52;-1:-1:-1;3008:9:13;;:37;;3031:14;:12;:14::i;:::-;3024:21;;:4;:21;:::i;:::-;3008:37;;;3020:1;3008:37;2998:47;;2795:257;;2694:358;;;;;:::o;2518:93:2:-;2565:13;2597:7;2590:14;;;;;:::i;3093:932:13:-;2356:21:7;:19;:21::i;:::-;3170:8:13::1;::::0;::::1;;3165:34;;3187:12;;-1:-1:-1::0;;;3187:12:13::1;;;;;;;;;;;3165:34;3213:15;::::0;::::1;::::0;::::1;;;:42:::0;::::1;;;;3233:22;3244:10;3233;:22::i;:::-;3232:23;3213:42;3209:66;;;3264:11;;-1:-1:-1::0;;;3264:11:13::1;;;;;;;;;;;3209:66;3289:13:::0;;;:42:::1;;;831:2;3306:8;:25;3289:42;3285:68;;;3340:13;;-1:-1:-1::0;;;3340:13:13::1;;;;;;;;;;;3285:68;3376:10;3367:20;::::0;;;:8:::1;:20;::::0;;;;;831:2:::1;::::0;3367:31:::1;::::0;3390:8;;3367:31:::1;:::i;:::-;:48;3363:72;;;3424:11;;-1:-1:-1::0;;;3424:11:13::1;;;;;;;;;;;3363:72;778:6;3463:8;3449:11;;:22;;;;:::i;:::-;:35;3445:57;;;3493:9;;-1:-1:-1::0;;;3493:9:13::1;;;;;;;;;;;3445:57;3514:12;3531:27;3537:10;3549:8;3531:5;:27::i;:::-;3513:45;;;3584:4;3572:9;:16;3568:40;;;3597:11;;-1:-1:-1::0;;;3597:11:13::1;;;;;;;;;;;3568:40;3628:10;3619:20;::::0;;;:8:::1;:20;::::0;;;;:32;;3643:8;;3619:20;:32:::1;::::0;3643:8;;3619:32:::1;:::i;:::-;::::0;;;-1:-1:-1;;3677:11:13::1;::::0;3661:13:::1;::::0;3677:15:::1;::::0;3691:1:::1;3677:15;:::i;:::-;3661:31;;3717:8;3702:11;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;3740:9:13::1;::::0;-1:-1:-1;3735:92:13::1;3755:8;3751:1;:12;3735:92;;;3784:32;3794:10;3806:9;3814:1:::0;3806:5;:9:::1;:::i;3784:32::-;3765:3;;3735:92;;;-1:-1:-1::0;3841:8:13;;3837:32:::1;;3857:5;::::0;3851:18:::1;::::0;3857:5;;::::1;-1:-1:-1::0;;;;;3857:5:13::1;3864:4:::0;3851:5:::1;:18::i;:::-;3895:4;3883:9;:16;3879:66;;;3901:44;3915:10;3928:16;3940:4:::0;3928:9:::1;:16;:::i;:::-;3901:5;:44::i;:::-;3977:41;::::0;;12106:25:14;;;12162:2;12147:18;;12140:34;;;12190:18;;;12183:34;;;3984:10:13::1;::::0;3977:41:::1;::::0;12094:2:14;12079:18;3977:41:13::1;;;;;;;3155:870;;2398:20:7::0;1713:1;2924:7;:21;2744:208;2398:20;3093:932:13;:::o;3718:144:2:-;3803:52;735:10:6;3836:8:2;3846;3803:18;:52::i;4985:208::-;5098:31;5111:4;5117:2;5121:7;5098:12;:31::i;:::-;5139:47;5162:4;5168:2;5172:7;5181:4;5139:22;:47::i;4888:249:13:-;4977:8;;4948:13;;-1:-1:-1;;;;;4977:8:13;:22;4973:123;;5015:17;5029:2;5015:13;:17::i;:::-;-1:-1:-1;5063:8:13;;5053:32;;-1:-1:-1;;;5053:32:13;;;;;2343:25:14;;;-1:-1:-1;;;;;5063:8:13;;;;5053:28;;2316:18:14;;5053:32:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5053:32:13;;;;;;;;;;;;:::i;4973:123::-;5112:18;5127:2;5112:14;:18::i;4143:93::-;1531:13:0;:11;:13::i;:::-;4207:15:13::1;:26:::0;;;::::1;;;;-1:-1:-1::0;;4207:26:13;;::::1;::::0;;;::::1;::::0;;4143:93::o;3928:153:2:-;-1:-1:-1;;;;;4039:25:2;;;4016:4;4039:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;3928:153::o;2543:215:0:-;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:0;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:0;;2700:1:::1;2672:31;::::0;::::1;1679:51:14::0;1652:18;;2672:31:0::1;1533:203:14::0;2623:91:0::1;2723:28;2742:8;2723:18;:28::i;4067:71:13:-:0;1531:13:0;:11;:13::i;:::-;4120:8:13::1;:15:::0;;-1:-1:-1;;4120:15:13::1;::::0;::::1;;::::0;;;::::1;::::0;;4067:71::o;16138:241:2:-;16201:7;5799:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5799:16:2;;16263:88;;16309:31;;-1:-1:-1;;;16309:31:2;;;;;2343:25:14;;;2316:18;;16309:31:2;2197:177:14;14418:120:2;14498:33;14507:2;14511:7;14520:4;14526;14498:8;:33::i;8838:795::-;8924:7;5799:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5799:16:2;;;;9035:18;;;9031:86;;9069:37;9086:4;9092;9098:7;9069:16;:37::i;:::-;-1:-1:-1;;;;;9161:18:2;;;9157:256;;9277:48;9294:1;9298:7;9315:1;9319:5;9277:8;:48::i;:::-;-1:-1:-1;;;;;9368:15:2;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9368:20:2;;;9157:256;-1:-1:-1;;;;;9427:16:2;;;9423:107;;-1:-1:-1;;;;;9487:13:2;;;;;;:9;:13;;;;;:18;;9504:1;9487:18;;;9423:107;9540:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9540:21:2;-1:-1:-1;;;;;9540:21:2;;;;;;;;;9577:27;;9540:16;;9577:27;;;;;;;9622:4;8838:795;-1:-1:-1;;;;8838:795:2:o;1796:162:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;735:10:6;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:6;1901:40:0;;;1679:51:14;1652:18;;1901:40:0;1533:203:14;10633:100:2;10700:26;10710:2;10714:7;10700:26;;;;;;;;;;;;:9;:26::i;2912:187:0:-;3004:6;;;-1:-1:-1;;;;;3020:17:0;;;-1:-1:-1;;;;;;3020:17:0;;;;;;;3052:40;;3004:6;;;3020:17;3004:6;;3052:40;;2985:16;;3052:40;2975:124;2912:187;:::o;2431:307:7:-;1755:1;2558:7;;:18;2554:86;;2599:30;;-1:-1:-1;;;2599:30:7;;;;;;;;;;;2554:86;1755:1;2714:7;:17;2431:307::o;5241:152:13:-;5311:7;5323:2;-1:-1:-1;;;;;5323:7:13;5338:6;5323:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5310:39;;;5364:2;5359:27;;5375:11;;-1:-1:-1;;;5375:11:13;;;;;;;;;;;15591:312:2;-1:-1:-1;;;;;15698:22:2;;15694:91;;15743:31;;-1:-1:-1;;;15743:31:2;;-1:-1:-1;;;;;1697:32:14;;15743:31:2;;;1679:51:14;1652:18;;15743:31:2;1533:203:14;15694:91:2;-1:-1:-1;;;;;15794:25:2;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;15794:46:2;;;;;;;;;;15855:41;;540::14;;;15855::2;;513:18:14;15855:41:2;;;;;;;15591:312;;;:::o;16918:782::-;-1:-1:-1;;;;;17034:14:2;;;:18;17030:664;;17072:71;;-1:-1:-1;;;17072:71:2;;-1:-1:-1;;;;;17072:36:2;;;;;:71;;735:10:6;;17123:4:2;;17129:7;;17138:4;;17072:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17072:71:2;;;;;;;;-1:-1:-1;;17072:71:2;;;;;;;;;;;;:::i;:::-;;;17068:616;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17381:6;:13;17398:1;17381:18;17377:293;;17430:25;;-1:-1:-1;;;17430:25:2;;-1:-1:-1;;;;;1697:32:14;;17430:25:2;;;1679:51:14;1652:18;;17430:25:2;1533:203:14;17377:293:2;17622:6;17616:13;17607:6;17603:2;17599:15;17592:38;17068:616;-1:-1:-1;;;;;;17190:51:2;;-1:-1:-1;;;17190:51:2;17186:130;;17272:25;;-1:-1:-1;;;17272:25:2;;-1:-1:-1;;;;;1697:32:14;;17272:25:2;;;1679:51:14;1652:18;;17272:25:2;1533:203:14;17186:130:2;17144:186;16918:782;;;;:::o;2677:255::-;2741:13;2766:22;2780:7;2766:13;:22::i;:::-;;2799:21;2823:10;:8;:10::i;:::-;2799:34;;2874:1;2856:7;2850:21;:25;:75;;;;;;;;;;;;;;;;;2892:7;2901:18;:7;:16;:18::i;:::-;2878:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2850:75;2843:82;2677:255;-1:-1:-1;;;2677:255:2:o;14720:662::-;14880:9;:31;;;-1:-1:-1;;;;;;14893:18:2;;;;14880:31;14876:460;;;14927:13;14943:22;14957:7;14943:13;:22::i;:::-;14927:38;-1:-1:-1;;;;;;15093:18:2;;;;;;:35;;;15124:4;-1:-1:-1;;;;;15115:13:2;:5;-1:-1:-1;;;;;15115:13:2;;;15093:35;:69;;;;;15133:29;15150:5;15157:4;15133:16;:29::i;:::-;15132:30;15093:69;15089:142;;;15189:27;;-1:-1:-1;;;15189:27:2;;-1:-1:-1;;;;;1697:32:14;;15189:27:2;;;1679:51:14;1652:18;;15189:27:2;1533:203:14;15089:142:2;15249:9;15245:81;;;15303:7;15299:2;-1:-1:-1;;;;;15283:28:2;15292:5;-1:-1:-1;;;;;15283:28:2;;;;;;;;;;;15245:81;14913:423;14876:460;-1:-1:-1;;15346:24:2;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15346:29:2;-1:-1:-1;;;;;15346:29:2;;;;;;;;;;14720:662::o;7082:368::-;7194:38;7208:5;7215:7;7224;7194:13;:38::i;:::-;7189:255;;-1:-1:-1;;;;;7252:19:2;;7248:186;;7298:31;;-1:-1:-1;;;7298:31:2;;;;;2343:25:14;;;2316:18;;7298:31:2;2197:177:14;7248:186:2;7375:44;;-1:-1:-1;;;7375:44:2;;-1:-1:-1;;;;;14532:32:14;;7375:44:2;;;14514:51:14;14581:18;;;14574:34;;;14487:18;;7375:44:2;14340:274:14;10954:182:2;11048:18;11054:2;11058:7;11048:5;:18::i;:::-;11076:53;11107:1;11111:2;11115:7;11124:4;11076:22;:53::i;5143:92:13:-;5195:13;5219;5212:20;;;;;:::i;637:698:8:-;693:13;742:14;759:17;770:5;759:10;:17::i;:::-;779:1;759:21;742:38;;794:20;828:6;817:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;817:18:8;-1:-1:-1;794:41:8;-1:-1:-1;955:28:8;;;971:2;955:28;1010:282;-1:-1:-1;;1041:5:8;-1:-1:-1;;;1175:2:8;1164:14;;1159:32;1041:5;1146:46;1236:2;1227:11;;;-1:-1:-1;1256:21:8;1010:282;1256:21;-1:-1:-1;1312:6:8;637:698;-1:-1:-1;;;637:698:8:o;6376:272:2:-;6479:4;-1:-1:-1;;;;;6514:21:2;;;;;;:127;;;6561:7;-1:-1:-1;;;;;6552:16:2;:5;-1:-1:-1;;;;;6552:16:2;;:52;;;;6572:32;6589:5;6596:7;6572:16;:32::i;:::-;6552:88;;;-1:-1:-1;6008:7:2;6034:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6608:32:2;;;6034:24;;6608:32;6552:88;6495:146;6376:272;-1:-1:-1;;;;6376:272:2:o;9955:327::-;-1:-1:-1;;;;;10022:16:2;;10018:87;;10061:33;;-1:-1:-1;;;10061:33:2;;10091:1;10061:33;;;1679:51:14;1652:18;;10061:33:2;1533:203:14;10018:87:2;10114:21;10138:32;10146:2;10150:7;10167:1;10138:7;:32::i;:::-;10114:56;-1:-1:-1;;;;;;10184:27:2;;;10180:96;;10234:31;;-1:-1:-1;;;10234:31:2;;10262:1;10234:31;;;1679:51:14;1652:18;;10234:31:2;1533:203:14;12214:916:11;12267:7;;-1:-1:-1;;;12342:17:11;;12338:103;;-1:-1:-1;;;12379:17:11;;;-1:-1:-1;12424:2:11;12414:12;12338:103;12467:8;12458:5;:17;12454:103;;12504:8;12495:17;;;-1:-1:-1;12540:2:11;12530:12;12454:103;12583:8;12574:5;:17;12570:103;;12620:8;12611:17;;;-1:-1:-1;12656:2:11;12646:12;12570:103;12699:7;12690:5;:16;12686:100;;12735:7;12726:16;;;-1:-1:-1;12770:1:11;12760:11;12686:100;12812:7;12803:5;:16;12799:100;;12848:7;12839:16;;;-1:-1:-1;12883:1:11;12873:11;12799:100;12925:7;12916:5;:16;12912:100;;12961:7;12952:16;;;-1:-1:-1;12996:1:11;12986:11;12912:100;13038:7;13029:5;:16;13025:66;;13075:1;13065:11;13117:6;12214:916;-1:-1:-1;;12214:916:11:o;14:131:14:-;-1:-1:-1;;;;;;88:32:14;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:14;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:14;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:14:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:14;;1348:180;-1:-1:-1;1348:180:14:o;1741:131::-;-1:-1:-1;;;;;1816:31:14;;1806:42;;1796:70;;1862:1;1859;1852:12;1877:315;1945:6;1953;2006:2;1994:9;1985:7;1981:23;1977:32;1974:52;;;2022:1;2019;2012:12;1974:52;2061:9;2048:23;2080:31;2105:5;2080:31;:::i;:::-;2130:5;2182:2;2167:18;;;;2154:32;;-1:-1:-1;;;1877:315:14:o;2379:456::-;2456:6;2464;2472;2525:2;2513:9;2504:7;2500:23;2496:32;2493:52;;;2541:1;2538;2531:12;2493:52;2580:9;2567:23;2599:31;2624:5;2599:31;:::i;:::-;2649:5;-1:-1:-1;2706:2:14;2691:18;;2678:32;2719:33;2678:32;2719:33;:::i;:::-;2379:456;;2771:7;;-1:-1:-1;;;2825:2:14;2810:18;;;;2797:32;;2379:456::o;2840:247::-;2899:6;2952:2;2940:9;2931:7;2927:23;2923:32;2920:52;;;2968:1;2965;2958:12;2920:52;3007:9;2994:23;3026:31;3051:5;3026:31;:::i;3352:592::-;3423:6;3431;3484:2;3472:9;3463:7;3459:23;3455:32;3452:52;;;3500:1;3497;3490:12;3452:52;3540:9;3527:23;3569:18;3610:2;3602:6;3599:14;3596:34;;;3626:1;3623;3616:12;3596:34;3664:6;3653:9;3649:22;3639:32;;3709:7;3702:4;3698:2;3694:13;3690:27;3680:55;;3731:1;3728;3721:12;3680:55;3771:2;3758:16;3797:2;3789:6;3786:14;3783:34;;;3813:1;3810;3803:12;3783:34;3858:7;3853:2;3844:6;3840:2;3836:15;3832:24;3829:37;3826:57;;;3879:1;3876;3869:12;3826:57;3910:2;3902:11;;;;;3932:6;;-1:-1:-1;3352:592:14;;-1:-1:-1;;;;3352:592:14:o;4202:160::-;4267:20;;4323:13;;4316:21;4306:32;;4296:60;;4352:1;4349;4342:12;4296:60;4202:160;;;:::o;4367:315::-;4432:6;4440;4493:2;4481:9;4472:7;4468:23;4464:32;4461:52;;;4509:1;4506;4499:12;4461:52;4548:9;4535:23;4567:31;4592:5;4567:31;:::i;:::-;4617:5;-1:-1:-1;4641:35:14;4672:2;4657:18;;4641:35;:::i;:::-;4631:45;;4367:315;;;;;:::o;4911:127::-;4972:10;4967:3;4963:20;4960:1;4953:31;5003:4;5000:1;4993:15;5027:4;5024:1;5017:15;5043:275;5114:2;5108:9;5179:2;5160:13;;-1:-1:-1;;5156:27:14;5144:40;;5214:18;5199:34;;5235:22;;;5196:62;5193:88;;;5261:18;;:::i;:::-;5297:2;5290:22;5043:275;;-1:-1:-1;5043:275:14:o;5323:186::-;5371:4;5404:18;5396:6;5393:30;5390:56;;;5426:18;;:::i;:::-;-1:-1:-1;5492:2:14;5471:15;-1:-1:-1;;5467:29:14;5498:4;5463:40;;5323:186::o;5514:1016::-;5609:6;5617;5625;5633;5686:3;5674:9;5665:7;5661:23;5657:33;5654:53;;;5703:1;5700;5693:12;5654:53;5742:9;5729:23;5761:31;5786:5;5761:31;:::i;:::-;5811:5;-1:-1:-1;5868:2:14;5853:18;;5840:32;5881:33;5840:32;5881:33;:::i;:::-;5933:7;-1:-1:-1;5987:2:14;5972:18;;5959:32;;-1:-1:-1;6042:2:14;6027:18;;6014:32;6069:18;6058:30;;6055:50;;;6101:1;6098;6091:12;6055:50;6124:22;;6177:4;6169:13;;6165:27;-1:-1:-1;6155:55:14;;6206:1;6203;6196:12;6155:55;6242:2;6229:16;6267:48;6283:31;6311:2;6283:31;:::i;:::-;6267:48;:::i;:::-;6338:2;6331:5;6324:17;6378:7;6373:2;6368;6364;6360:11;6356:20;6353:33;6350:53;;;6399:1;6396;6389:12;6350:53;6454:2;6449;6445;6441:11;6436:2;6429:5;6425:14;6412:45;6498:1;6493:2;6488;6481:5;6477:14;6473:23;6466:34;6519:5;6509:15;;;;;5514:1016;;;;;;;:::o;6765:180::-;6821:6;6874:2;6862:9;6853:7;6849:23;6845:32;6842:52;;;6890:1;6887;6880:12;6842:52;6913:26;6929:9;6913:26;:::i;6950:388::-;7018:6;7026;7079:2;7067:9;7058:7;7054:23;7050:32;7047:52;;;7095:1;7092;7085:12;7047:52;7134:9;7121:23;7153:31;7178:5;7153:31;:::i;:::-;7203:5;-1:-1:-1;7260:2:14;7245:18;;7232:32;7273:33;7232:32;7273:33;:::i;:::-;7325:7;7315:17;;;6950:388;;;;;:::o;7343:380::-;7422:1;7418:12;;;;7465;;;7486:61;;7540:4;7532:6;7528:17;7518:27;;7486:61;7593:2;7585:6;7582:14;7562:18;7559:38;7556:161;;7639:10;7634:3;7630:20;7627:1;7620:31;7674:4;7671:1;7664:15;7702:4;7699:1;7692:15;7556:161;;7343:380;;;:::o;8108:179::-;8186:13;;8239:22;8228:34;;8218:45;;8208:73;;8277:1;8274;8267:12;8292:473;8395:6;8403;8411;8419;8427;8480:3;8468:9;8459:7;8455:23;8451:33;8448:53;;;8497:1;8494;8487:12;8448:53;8520:39;8549:9;8520:39;:::i;:::-;8510:49;;8599:2;8588:9;8584:18;8578:25;8568:35;;8643:2;8632:9;8628:18;8622:25;8612:35;;8687:2;8676:9;8672:18;8666:25;8656:35;;8710:49;8754:3;8743:9;8739:19;8710:49;:::i;:::-;8700:59;;8292:473;;;;;;;;:::o;8770:127::-;8831:10;8826:3;8822:20;8819:1;8812:31;8862:4;8859:1;8852:15;8886:4;8883:1;8876:15;8902:128;8969:9;;;8990:11;;;8987:37;;;9004:18;;:::i;9035:168::-;9108:9;;;9139;;9156:15;;;9150:22;;9136:37;9126:71;;9177:18;;:::i;9340:217::-;9380:1;9406;9396:132;;9450:10;9445:3;9441:20;9438:1;9431:31;9485:4;9482:1;9475:15;9513:4;9510:1;9503:15;9396:132;-1:-1:-1;9542:9:14;;9340:217::o;9562:125::-;9627:9;;;9648:10;;;9645:36;;;9661:18;;:::i;9692:184::-;9762:6;9815:2;9803:9;9794:7;9790:23;9786:32;9783:52;;;9831:1;9828;9821:12;9783:52;-1:-1:-1;9854:16:14;;9692:184;-1:-1:-1;9692:184:14:o;10007:518::-;10109:2;10104:3;10101:11;10098:421;;;10145:5;10142:1;10135:16;10189:4;10186:1;10176:18;10259:2;10247:10;10243:19;10240:1;10236:27;10230:4;10226:38;10295:4;10283:10;10280:20;10277:47;;;-1:-1:-1;10318:4:14;10277:47;10373:2;10368:3;10364:12;10361:1;10357:20;10351:4;10347:31;10337:41;;10428:81;10446:2;10439:5;10436:13;10428:81;;;10505:1;10491:16;;10472:1;10461:13;10428:81;;10701:1198;10825:18;10820:3;10817:27;10814:53;;;10847:18;;:::i;:::-;10876:94;10966:3;10926:38;10958:4;10952:11;10926:38;:::i;:::-;10920:4;10876:94;:::i;:::-;10996:1;11021:2;11016:3;11013:11;11038:1;11033:608;;;;11685:1;11702:3;11699:93;;;-1:-1:-1;11758:19:14;;;11745:33;11699:93;-1:-1:-1;;10658:1:14;10654:11;;;10650:24;10646:29;10636:40;10682:1;10678:11;;;10633:57;11805:78;;11006:887;;11033:608;9954:1;9947:14;;;9991:4;9978:18;;-1:-1:-1;;11069:17:14;;;11184:229;11198:7;11195:1;11192:14;11184:229;;;11287:19;;;11274:33;11259:49;;11394:4;11379:20;;;;11347:1;11335:14;;;;11214:12;11184:229;;;11188:3;11441;11432:7;11429:16;11426:159;;;11565:1;11561:6;11555:3;11549;11546:1;11542:11;11538:21;11534:34;11530:39;11517:9;11512:3;11508:19;11495:33;11491:79;11483:6;11476:95;11426:159;;;11628:1;11622:3;11619:1;11615:11;11611:19;11605:4;11598:33;11006:887;;10701:1198;;;:::o;12228:648::-;12308:6;12361:2;12349:9;12340:7;12336:23;12332:32;12329:52;;;12377:1;12374;12367:12;12329:52;12410:9;12404:16;12443:18;12435:6;12432:30;12429:50;;;12475:1;12472;12465:12;12429:50;12498:22;;12551:4;12543:13;;12539:27;-1:-1:-1;12529:55:14;;12580:1;12577;12570:12;12529:55;12609:2;12603:9;12634:48;12650:31;12678:2;12650:31;:::i;12634:48::-;12705:2;12698:5;12691:17;12745:7;12740:2;12735;12731;12727:11;12723:20;12720:33;12717:53;;;12766:1;12763;12756:12;12717:53;12779:67;12843:2;12838;12831:5;12827:14;12822:2;12818;12814:11;12779:67;:::i;:::-;12865:5;12228:648;-1:-1:-1;;;;;12228:648:14:o;13091:489::-;-1:-1:-1;;;;;13360:15:14;;;13342:34;;13412:15;;13407:2;13392:18;;13385:43;13459:2;13444:18;;13437:34;;;13507:3;13502:2;13487:18;;13480:31;;;13285:4;;13528:46;;13554:19;;13546:6;13528:46;:::i;:::-;13520:54;13091:489;-1:-1:-1;;;;;;13091:489:14:o;13585:249::-;13654:6;13707:2;13695:9;13686:7;13682:23;13678:32;13675:52;;;13723:1;13720;13713:12;13675:52;13755:9;13749:16;13774:30;13798:5;13774:30;:::i;13839:496::-;14018:3;14056:6;14050:13;14072:66;14131:6;14126:3;14119:4;14111:6;14107:17;14072:66;:::i;:::-;14201:13;;14160:16;;;;14223:70;14201:13;14160:16;14270:4;14258:17;;14223:70;:::i;:::-;14309:20;;13839:496;-1:-1:-1;;;;13839:496:14:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122042821153380876681387cacd8ca2622da83aac176a0f54daeb17b5dc7f48f96d64736f6c63430008180033","offset":7687}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xfda251a594fae8698b1e686d5a3f01a76e6284452906387702f9219e1b67f1af","blockNumber":"129679021","transactionIndex":"45","deployer":"0x0b7c7A171D4385c7b4e308D81605B764cE88F0Ed"},"sources":{"AgentDrop.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {ERC721} from \"@openzeppelin/contracts/token/ERC721/ERC721.sol\";\nimport {Ownable} from \"@openzeppelin/contracts/access/Ownable.sol\";\nimport {ReentrancyGuard} from \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\n\ninterface IRenderer {\n    function tokenURI(uint256 id) external view returns (string memory);\n}\n\ninterface IAggregatorV3 {\n    function latestRoundData()\n        external\n        view\n        returns (uint80, int256 answer, uint256, uint256 updatedAt, uint80);\n}\n\n/// @title Agent ID-gated NFT: 10,000 supply, max 10 per wallet,\n///        first mint per wallet free, then $0.30 each paid in BNB.\ncontract AgentDrop is ERC721, Ownable, ReentrancyGuard {\n    uint256 public constant MAX_SUPPLY = 10_000;\n    uint256 public constant MAX_PER_WALLET = 10;\n    uint256 public constant FREE_PER_WALLET = 1;\n    uint256 public constant PRICE_USD_CENTS = 30; // $0.30\n\n    // BNB Chain mainnet\n    IAggregatorV3 public constant BNB_USD = IAggregatorV3(0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE); // Chainlink BNB/USD, 8 decimals\n    address public constant AGENT_ID = 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F; // Binance .ai Agent ID\n\n    uint256 public totalMinted;\n    bool public mintOpen;\n    bool public agentIdRequired = true;\n    address payable public payee;\n    string private _baseTokenURI;\n    address public renderer; // on-chain art contract; overrides baseURI when set\n\n    mapping(address => uint256) public mintedBy;\n\n    error MintClosed();\n    error NoAgentId();\n    error BadQuantity();\n    error OverLimit();\n    error SoldOut();\n    error Underpaid();\n    error StalePrice();\n    error PayFailed();\n\n    event Minted(address indexed to, uint256 firstId, uint256 quantity, uint256 paidWei);\n\n    constructor(string memory name_, string memory symbol_, string memory baseURI_, address payable payee_, address owner_)\n        ERC721(name_, symbol_)\n        Ownable(owner_)\n    {\n        _baseTokenURI = baseURI_;\n        payee = payee_;\n    }\n\n    // ---------- views ----------\n\n    function hasAgentId(address a) public view returns (bool) {\n        return ERC721(AGENT_ID).balanceOf(a) > 0;\n    }\n\n    /// @notice BNB (wei) for one paid piece at Chainlink's price.\n    function unitPriceWei() public view returns (uint256) {\n        (, int256 answer,, uint256 updatedAt,) = BNB_USD.latestRoundData();\n        if (answer <= 0 || block.timestamp - updatedAt > 1 hours) revert StalePrice();\n        // cents * 1e18 * 1e8 / (answer * 100)\n        return (PRICE_USD_CENTS * 1e24) / uint256(answer);\n    }\n\n    /// @notice Cost in wei and how many pieces are paid for `minter` minting `quantity`.\n    function quote(address minter, uint256 quantity) public view returns (uint256 costWei, uint256 paid) {\n        uint256 already = mintedBy[minter];\n        uint256 freeLeft = already >= FREE_PER_WALLET ? 0 : FREE_PER_WALLET - already;\n        paid = quantity > freeLeft ? quantity - freeLeft : 0;\n        costWei = paid == 0 ? 0 : paid * unitPriceWei();\n    }\n\n    // ---------- mint ----------\n\n    function mint(uint256 quantity) external payable nonReentrant {\n        if (!mintOpen) revert MintClosed();\n        if (agentIdRequired && !hasAgentId(msg.sender)) revert NoAgentId();\n        if (quantity == 0 || quantity > MAX_PER_WALLET) revert BadQuantity();\n        if (mintedBy[msg.sender] + quantity > MAX_PER_WALLET) revert OverLimit();\n        if (totalMinted + quantity > MAX_SUPPLY) revert SoldOut();\n\n        (uint256 cost,) = quote(msg.sender, quantity);\n        if (msg.value < cost) revert Underpaid();\n\n        mintedBy[msg.sender] += quantity;\n        uint256 first = totalMinted + 1;\n        totalMinted += quantity;\n        for (uint256 i; i < quantity; ++i) {\n            _safeMint(msg.sender, first + i);\n        }\n\n        if (cost > 0) _send(payee, cost);\n        if (msg.value > cost) _send(payable(msg.sender), msg.value - cost); // refund extra\n\n        emit Minted(msg.sender, first, quantity, cost);\n    }\n\n    // ---------- owner ----------\n\n    function setMintOpen(bool open) external onlyOwner { mintOpen = open; }\n    function setAgentIdRequired(bool required) external onlyOwner { agentIdRequired = required; }\n    function setPayee(address payable p) external onlyOwner { payee = p; }\n    function setRenderer(address r) external onlyOwner { renderer = r; }\n    function setBaseURI(string calldata uri) external onlyOwner { _baseTokenURI = uri; }\n\n    /// @notice Owner may mint up to the supply cap (e.g. for the team), free.\n    function ownerMint(address to, uint256 quantity) external onlyOwner {\n        if (totalMinted + quantity > MAX_SUPPLY) revert SoldOut();\n        uint256 first = totalMinted + 1;\n        totalMinted += quantity;\n        for (uint256 i; i < quantity; ++i) _safeMint(to, first + i);\n    }\n\n    // ---------- internal ----------\n\n    function tokenURI(uint256 id) public view override returns (string memory) {\n        if (renderer != address(0)) {\n            _requireOwned(id);\n            return IRenderer(renderer).tokenURI(id);\n        }\n        return super.tokenURI(id);\n    }\n\n    function _baseURI() internal view override returns (string memory) { return _baseTokenURI; }\n\n    function _send(address payable to, uint256 amount) private {\n        (bool ok,) = to.call{value: amount}(\"\");\n        if (!ok) revert PayFailed();\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721} from \"./IERC721.sol\";\nimport {IERC721Receiver} from \"./IERC721Receiver.sol\";\nimport {IERC721Metadata} from \"./extensions/IERC721Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {Strings} from \"../../utils/Strings.sol\";\nimport {IERC165, ERC165} from \"../../utils/introspection/ERC165.sol\";\nimport {IERC721Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\nabstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {\n    using Strings for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    mapping(uint256 tokenId => address) private _owners;\n\n    mapping(address owner => uint256) private _balances;\n\n    mapping(uint256 tokenId => address) private _tokenApprovals;\n\n    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return\n            interfaceId == type(IERC721).interfaceId ||\n            interfaceId == type(IERC721Metadata).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev See {IERC721-balanceOf}.\n     */\n    function balanceOf(address owner) public view virtual returns (uint256) {\n        if (owner == address(0)) {\n            revert ERC721InvalidOwner(address(0));\n        }\n        return _balances[owner];\n    }\n\n    /**\n     * @dev See {IERC721-ownerOf}.\n     */\n    function ownerOf(uint256 tokenId) public view virtual returns (address) {\n        return _requireOwned(tokenId);\n    }\n\n    /**\n     * @dev See {IERC721Metadata-name}.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-symbol}.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-tokenURI}.\n     */\n    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {\n        _requireOwned(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /**\n     * @dev See {IERC721-approve}.\n     */\n    function approve(address to, uint256 tokenId) public virtual {\n        _approve(to, tokenId, _msgSender());\n    }\n\n    /**\n     * @dev See {IERC721-getApproved}.\n     */\n    function getApproved(uint256 tokenId) public view virtual returns (address) {\n        _requireOwned(tokenId);\n\n        return _getApproved(tokenId);\n    }\n\n    /**\n     * @dev See {IERC721-setApprovalForAll}.\n     */\n    function setApprovalForAll(address operator, bool approved) public virtual {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /**\n     * @dev See {IERC721-isApprovedForAll}.\n     */\n    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /**\n     * @dev See {IERC721-transferFrom}.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) public virtual {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        // Setting an \"auth\" arguments enables the `_isAuthorized` check which verifies that the token exists\n        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.\n        address previousOwner = _update(to, tokenId, _msgSender());\n        if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) public {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {\n        transferFrom(from, to, tokenId);\n        _checkOnERC721Received(from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     *\n     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the\n     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances\n     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by\n     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.\n     */\n    function _getApproved(uint256 tokenId) internal view virtual returns (address) {\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in\n     * particular (ignoring whether it is owned by `owner`).\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {\n        return\n            spender != address(0) &&\n            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.\n     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets\n     * the `spender` for the specific `tokenId`.\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {\n        if (!_isAuthorized(owner, spender, tokenId)) {\n            if (owner == address(0)) {\n                revert ERC721NonexistentToken(tokenId);\n            } else {\n                revert ERC721InsufficientApproval(spender, tokenId);\n            }\n        }\n    }\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that\n     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.\n     *\n     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the\n     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership\n     * remain consistent with one another.\n     */\n    function _increaseBalance(address account, uint128 value) internal virtual {\n        unchecked {\n            _balances[account] += value;\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner\n     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that\n     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.\n     */\n    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {\n        address from = _ownerOf(tokenId);\n\n        // Perform (optional) operator check\n        if (auth != address(0)) {\n            _checkAuthorized(from, auth, tokenId);\n        }\n\n        // Execute the update\n        if (from != address(0)) {\n            // Clear approval. No need to re-authorize or emit the Approval event\n            _approve(address(0), tokenId, address(0), false);\n\n            unchecked {\n                _balances[from] -= 1;\n            }\n        }\n\n        if (to != address(0)) {\n            unchecked {\n                _balances[to] += 1;\n            }\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        return from;\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner != address(0)) {\n            revert ERC721InvalidSender(address(0));\n        }\n    }\n\n    /**\n     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        _checkOnERC721Received(address(0), to, tokenId, data);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal {\n        address previousOwner = _update(address(0), tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        } else if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients\n     * are aware of the ERC721 standard to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is like {safeTransferFrom} in the sense that it invokes\n     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `tokenId` token must exist and be owned by `from`.\n     * - `to` cannot be the zero address.\n     * - `from` cannot be the zero address.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId) internal {\n        _safeTransfer(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        _checkOnERC721Received(from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is\n     * either the owner of the token, or approved to operate on all tokens held by this owner.\n     *\n     * Emits an {Approval} event.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address to, uint256 tokenId, address auth) internal {\n        _approve(to, tokenId, auth, true);\n    }\n\n    /**\n     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not\n     * emitted in the context of transfers.\n     */\n    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {\n        // Avoid reading the owner unless necessary\n        if (emitEvent || auth != address(0)) {\n            address owner = _requireOwned(tokenId);\n\n            // We do not use _isAuthorized because single-token approvals should not be able to call approve\n            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {\n                revert ERC721InvalidApprover(auth);\n            }\n\n            if (emitEvent) {\n                emit Approval(owner, to, tokenId);\n            }\n        }\n\n        _tokenApprovals[tokenId] = to;\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Requirements:\n     * - operator can't be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        if (operator == address(0)) {\n            revert ERC721InvalidOperator(operator);\n        }\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).\n     * Returns the owner.\n     *\n     * Overrides to ownership logic should be done to {_ownerOf}.\n     */\n    function _requireOwned(uint256 tokenId) internal view returns (address) {\n        address owner = _ownerOf(tokenId);\n        if (owner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n        return owner;\n    }\n\n    /**\n     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the\n     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.\n     *\n     * @param from address representing the previous owner of the given token ID\n     * @param to target address that will receive the tokens\n     * @param tokenId uint256 ID of the token to be transferred\n     * @param data bytes optional data to send along with the call\n     */\n    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {\n                if (retval != IERC721Receiver.onERC721Received.selector) {\n                    revert ERC721InvalidReceiver(to);\n                }\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    revert ERC721InvalidReceiver(to);\n                } else {\n                    /// @solidity memory-safe-assembly\n                    assembly {\n                        revert(add(32, reason), mload(reason))\n                    }\n                }\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../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 * The initial owner is set to the address provided by the deployer. This can\n * 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    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\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        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\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        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\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"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n     *   {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721} from \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)\n\npragma solidity ^0.8.20;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard ERC20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    /**\n     * @dev Muldiv operation overflow.\n     */\n    error MathOverflowedMulDiv();\n\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return 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 towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            return a / b;\n        }\n\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\n     * denominator == 0.\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 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 = x * y; // 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                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            if (denominator <= prod1) {\n                revert MathOverflowedMulDiv();\n            }\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.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\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\n            // works 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 (unsignedRoundsUp(rounding) && 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\n     * towards zero.\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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.24+commit.e11b9ed9","compilerSettings":{"optimizer":{"runs":200,"enabled":true}},"name":"AgentDrop","fullyQualifiedName":"AgentDrop.sol:AgentDrop"},"abi":[{"type":"constructor","inputs":[{"name":"name_","type":"string","internalType":"string"},{"name":"symbol_","type":"string","internalType":"string"},{"name":"baseURI_","type":"string","internalType":"string"},{"name":"payee_","type":"address","internalType":"address payable"},{"name":"owner_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"BadQuantity","type":"error","inputs":[]},{"name":"ERC721IncorrectOwner","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InsufficientApproval","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"ERC721InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOperator","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC721NonexistentToken","type":"error","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"MintClosed","type":"error","inputs":[]},{"name":"NoAgentId","type":"error","inputs":[]},{"name":"OverLimit","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"PayFailed","type":"error","inputs":[]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SoldOut","type":"error","inputs":[]},{"name":"StalePrice","type":"error","inputs":[]},{"name":"Underpaid","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"ApprovalForAll","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"operator","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Minted","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"firstId","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"quantity","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"paidWei","type":"uint256","indexed":false,"internalType":"uint256"}],"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":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"AGENT_ID","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"BNB_USD","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IAggregatorV3"}],"stateMutability":"view"},{"name":"FREE_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PRICE_USD_CENTS","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"agentIdRequired","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"hasAgentId","type":"function","inputs":[{"name":"a","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isApprovedForAll","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"quantity","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"mintOpen","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mintedBy","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"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":"ownerMint","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"quantity","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"payee","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address payable"}],"stateMutability":"view"},{"name":"quote","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"},{"name":"quantity","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"costWei","type":"uint256","internalType":"uint256"},{"name":"paid","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"renderer","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setAgentIdRequired","type":"function","inputs":[{"name":"required","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setApprovalForAll","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"approved","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBaseURI","type":"function","inputs":[{"name":"uri","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMintOpen","type":"function","inputs":[{"name":"open","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPayee","type":"function","inputs":[{"name":"p","type":"address","internalType":"address payable"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRenderer","type":"function","inputs":[{"name":"r","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unitPriceWei","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.24+commit.e11b9ed9"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"string","name":"baseURI_","type":"string"},{"internalType":"address payable","name":"payee_","type":"address"},{"internalType":"address","name":"owner_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BadQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[],"name":"MintClosed","type":"error"},{"inputs":[],"name":"NoAgentId","type":"error"},{"inputs":[],"name":"OverLimit","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"PayFailed","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"SoldOut","type":"error"},{"inputs":[],"name":"StalePrice","type":"error"},{"inputs":[],"name":"Underpaid","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"firstId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"paidWei","type":"uint256"}],"name":"Minted","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":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"AGENT_ID","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BNB_USD","outputs":[{"internalType":"contract IAggregatorV3","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FREE_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE_USD_CENTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"agentIdRequired","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"a","type":"address"}],"name":"hasAgentId","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintedBy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"address","name":"to","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"payee","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"quote","outputs":[{"internalType":"uint256","name":"costWei","type":"uint256"},{"internalType":"uint256","name":"paid","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renderer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"required","type":"bool"}],"name":"setAgentIdRequired","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"open","type":"bool"}],"name":"setMintOpen","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"p","type":"address"}],"name":"setPayee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"r","type":"address"}],"name":"setRenderer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unitPriceWei","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],"devdoc":{"errors":{"ERC721IncorrectOwner(address,uint256,address)":[{"details":"Indicates an error related to the ownership over a particular token. Used in transfers.","params":{"owner":"Address of the current owner of a token.","sender":"Address whose tokens are being transferred.","tokenId":"Identifier number of a token."}}],"ERC721InsufficientApproval(address,uint256)":[{"details":"Indicates a failure with the `operator`’s approval. Used in transfers.","params":{"operator":"Address that may be allowed to operate on tokens without being their owner.","tokenId":"Identifier number of a token."}}],"ERC721InvalidApprover(address)":[{"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals.","params":{"approver":"Address initiating an approval operation."}}],"ERC721InvalidOperator(address)":[{"details":"Indicates a failure with the `operator` to be approved. Used in approvals.","params":{"operator":"Address that may be allowed to operate on tokens without being their owner."}}],"ERC721InvalidOwner(address)":[{"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. Used in balance queries.","params":{"owner":"Address of the current owner of a token."}}],"ERC721InvalidReceiver(address)":[{"details":"Indicates a failure with the token `receiver`. Used in transfers.","params":{"receiver":"Address to which tokens are being transferred."}}],"ERC721InvalidSender(address)":[{"details":"Indicates a failure with the token `sender`. Used in transfers.","params":{"sender":"Address whose tokens are being transferred."}}],"ERC721NonexistentToken(uint256)":[{"details":"Indicates a `tokenId` whose `owner` is the zero address.","params":{"tokenId":"Identifier number of a token."}}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."}},"kind":"dev","methods":{"approve(address,uint256)":{"details":"See {IERC721-approve}."},"balanceOf(address)":{"details":"See {IERC721-balanceOf}."},"getApproved(uint256)":{"details":"See {IERC721-getApproved}."},"isApprovedForAll(address,address)":{"details":"See {IERC721-isApprovedForAll}."},"name()":{"details":"See {IERC721Metadata-name}."},"owner()":{"details":"Returns the address of the current owner."},"ownerOf(uint256)":{"details":"See {IERC721-ownerOf}."},"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."},"safeTransferFrom(address,address,uint256)":{"details":"See {IERC721-safeTransferFrom}."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"See {IERC721-safeTransferFrom}."},"setApprovalForAll(address,bool)":{"details":"See {IERC721-setApprovalForAll}."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"symbol()":{"details":"See {IERC721Metadata-symbol}."},"transferFrom(address,address,uint256)":{"details":"See {IERC721-transferFrom}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"title":"Agent ID-gated NFT: 10,000 supply, max 10 per wallet,        first mint per wallet free, then $0.30 each paid in BNB.","version":1},"userdoc":{"kind":"user","methods":{"ownerMint(address,uint256)":{"notice":"Owner may mint up to the supply cap (e.g. for the team), free."},"quote(address,uint256)":{"notice":"Cost in wei and how many pieces are paid for `minter` minting `quantity`."},"unitPriceWei()":{"notice":"BNB (wei) for one paid piece at Chainlink's price."}},"version":1}},"settings":{"compilationTarget":{"AgentDrop.sol":"AgentDrop"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"@openzeppelin/contracts/access/Ownable.sol":{"keccak256":"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb","license":"MIT","urls":["bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6","dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a"]},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"keccak256":"0x60c65f701957fdd6faea1acb0bb45825791d473693ed9ecb34726fdfaa849dd7","license":"MIT","urls":["bzz-raw://ea290300e0efc4d901244949dc4d877fd46e6c5e43dc2b26620e8efab3ab803f","dweb:/ipfs/QmcLLJppxKeJWqHxE2CUkcfhuRTgHSn8J4kijcLa5MYhSt"]},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"keccak256":"0x13dd061770956c8489b80cfc89d9cdfc8ea2783d953691ea037a380731d52784","license":"MIT","urls":["bzz-raw://ed37f0f86e7fe31659e48c3a2a5920a92dd7f13c85cf8991fb79fe5f01e08efd","dweb:/ipfs/QmUtm9bQGvjr9hHGwkPWrbgFmVqzaJcxjkaYDex2oGsonS"]},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"keccak256":"0x5ef46daa3b58ef2702279d514780316efaa952915ee1aa3396f041ee2982b0b4","license":"MIT","urls":["bzz-raw://2f8f2a76e23b02fc69e8cd24c3cb47da6c7af3a2d6c3a382f8ac25c6e094ade7","dweb:/ipfs/QmPV4ZS4tPVv4mTCf9ejyZ1ai57EEibDRj7mN2ARDCLV5n"]},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"keccak256":"0x7f7a26306c79a65fb8b3b6c757cd74660c532cd8a02e165488e30027dd34ca49","license":"MIT","urls":["bzz-raw://d01e0b2b837ee2f628545e54d8715b49c7ef2befd08356c2e7f6c50dde8a1c22","dweb:/ipfs/QmWBAn6y2D1xgftci97Z3qR9tQnkvwQpYwFwkTvDMvqU4i"]},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"keccak256":"0x37d1aaaa5a2908a09e9dcf56a26ddf762ecf295afb5964695937344fc6802ce1","license":"MIT","urls":["bzz-raw://ed0bfc1b92153c5000e50f4021367b931bbe96372ac6facec3c4961b72053d02","dweb:/ipfs/Qmbwp8VDerjS5SV1quwHH1oMXxPQ93fzfLVqJ2RCqbowGE"]},"@openzeppelin/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"keccak256":"0xf980daa263b661ab8ddee7d4fd833c7da7e7995e2c359ff1f17e67e4112f2236","license":"MIT","urls":["bzz-raw://7448ab095d6940130bcf76ba47a2eab14148c83119523b93dd89f6d84edd6c02","dweb:/ipfs/QmawrZ4voKQjH3oomXT3Kuheb3Mnmo2VvVpxg8Ne5UJUrd"]},"@openzeppelin/contracts/utils/Strings.sol":{"keccak256":"0x55f102ea785d8399c0e58d1108e2d289506dde18abc6db1b7f68c1f9f9bc5792","license":"MIT","urls":["bzz-raw://6e52e0a7765c943ef14e5bcf11e46e6139fa044be564881378349236bf2e3453","dweb:/ipfs/QmZEeeXoFPW47amyP35gfzomF9DixqqTEPwzBakv6cZw6i"]},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"keccak256":"0x9e8778b14317ba9e256c30a76fd6c32b960af621987f56069e1e819c77c6a133","license":"MIT","urls":["bzz-raw://1777404f1dcd0fac188e55a288724ec3c67b45288e49cc64723e95e702b49ab8","dweb:/ipfs/QmZFdC626GButBApwDUvvTnUzdinevC3B24d7yyh57XkiA"]},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x4296879f55019b23e135000eb36896057e7101fb7fb859c5ef690cf14643757b","license":"MIT","urls":["bzz-raw://87b3541437c8c443ccd36795e56a338ed12855eec17f8da624511b8d1a7e14df","dweb:/ipfs/QmeJQCtZrQjtJLr6u7ZHWeH3pBnjtLWzvRrKViAi7UZqxL"]},"@openzeppelin/contracts/utils/math/Math.sol":{"keccak256":"0x005ec64c6313f0555d59e278f9a7a5ab2db5bdc72a027f255a37c327af1ec02d","license":"MIT","urls":["bzz-raw://4ece9f0b9c8daca08c76b6b5405a6446b6f73b3a15fab7ff56e296cbd4a2c875","dweb:/ipfs/QmQyRpyPRL5SQuAgj6SHmbir3foX65FJjbVTTQrA2EFg6L"]},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"keccak256":"0x5f7e4076e175393767754387c962926577f1660dd9b810187b9002407656be72","license":"MIT","urls":["bzz-raw://7d533a1c97cd43a57cd9c465f7ee8dd0e39ae93a8fb8ff8e5303a356b081cdcc","dweb:/ipfs/QmVBEei6aTnvYNZp2CHYVNKyZS4q1KkjANfY39WVXZXVoT"]},"AgentDrop.sol":{"keccak256":"0xa5cafd6ae3856c9c0de02ef9cab948fdc852bfa720544f3dfc77bf24525097dd","license":"MIT","urls":["bzz-raw://ebee5d98d13ac751577121f1b33a797902df20adbd0a9e0ca1dc9ff66333c454","dweb:/ipfs/QmPqT6FwXUGsbGps8o6cawGrBSWJZF3pJh4oFaVdNkodGu"]}},"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_address_payable":{"label":"address payable","encoding":"inplace","numberOfBytes":"20"},"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_uint256,t_address)":{"key":"t_uint256","label":"mapping(uint256 => address)","value":"t_address","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_bool))":{"key":"t_address","label":"mapping(address => mapping(address => bool))","value":"t_mapping(t_address,t_bool)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_string_storage","astId":317,"label":"_name","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"1","type":"t_string_storage","astId":319,"label":"_symbol","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"2","type":"t_mapping(t_uint256,t_address)","astId":323,"label":"_owners","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"3","type":"t_mapping(t_address,t_uint256)","astId":327,"label":"_balances","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"4","type":"t_mapping(t_uint256,t_address)","astId":331,"label":"_tokenApprovals","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"5","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":337,"label":"_operatorApprovals","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"6","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"7","type":"t_uint256","astId":1497,"label":"_status","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"8","type":"t_uint256","astId":3065,"label":"totalMinted","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"9","type":"t_bool","astId":3067,"label":"mintOpen","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"9","type":"t_bool","astId":3070,"label":"agentIdRequired","offset":1,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"9","type":"t_address_payable","astId":3072,"label":"payee","offset":2,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"10","type":"t_string_storage","astId":3074,"label":"_baseTokenURI","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"11","type":"t_address","astId":3076,"label":"renderer","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"12","type":"t_mapping(t_address,t_uint256)","astId":3080,"label":"mintedBy","offset":0,"contract":"AgentDrop.sol:AgentDrop"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{"unitPriceWei()":{"notice":"BNB (wei) for one paid piece at Chainlink's price."},"quote(address,uint256)":{"notice":"Cost in wei and how many pieces are paid for `minter` minting `quantity`."},"ownerMint(address,uint256)":{"notice":"Owner may mint up to the supply cap (e.g. for the team), free."}},"version":1},"devdoc":{"kind":"dev","title":"Agent ID-gated NFT: 10,000 supply, max 10 per wallet,        first mint per wallet free, then $0.30 each paid in BNB.","errors":{"ERC721InvalidOwner(address)":[{"params":{"owner":"Address of the current owner of a token."},"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. Used in balance queries."}],"ERC721InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"ERC721InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC721InvalidOperator(address)":[{"params":{"operator":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `operator` to be approved. Used in approvals."}],"ERC721InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"ERC721NonexistentToken(uint256)":[{"params":{"tokenId":"Identifier number of a token."},"details":"Indicates a `tokenId` whose `owner` is the zero address."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ERC721InsufficientApproval(address,uint256)":[{"params":{"tokenId":"Identifier number of a token.","operator":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `operator`’s approval. Used in transfers."}],"ERC721IncorrectOwner(address,uint256,address)":[{"params":{"owner":"Address of the current owner of a token.","sender":"Address whose tokens are being transferred.","tokenId":"Identifier number of a token."},"details":"Indicates an error related to the ownership over a particular token. Used in transfers."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."}},"methods":{"name()":{"details":"See {IERC721Metadata-name}."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"See {IERC721Metadata-symbol}."},"ownerOf(uint256)":{"details":"See {IERC721-ownerOf}."},"balanceOf(address)":{"details":"See {IERC721-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."},"getApproved(uint256)":{"details":"See {IERC721-getApproved}."},"approve(address,uint256)":{"details":"See {IERC721-approve}."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"setApprovalForAll(address,bool)":{"details":"See {IERC721-setApprovalForAll}."},"isApprovedForAll(address,address)":{"details":"See {IERC721-isApprovedForAll}."},"transferFrom(address,address,uint256)":{"details":"See {IERC721-transferFrom}."},"safeTransferFrom(address,address,uint256)":{"details":"See {IERC721-safeTransferFrom}."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"See {IERC721-safeTransferFrom}."}},"version":1},"sourceIds":{"AgentDrop.sol":{"id":13},"@openzeppelin/contracts/utils/Context.sol":{"id":6},"@openzeppelin/contracts/utils/Strings.sol":{"id":8},"@openzeppelin/contracts/access/Ownable.sol":{"id":0},"@openzeppelin/contracts/utils/math/Math.sol":{"id":11},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"id":2},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"id":3},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"id":7},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"id":12},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":1},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":9},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":10},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"id":4},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"id":5}},"additionalInput":null,"stdJsonInput":{"sources":{"AgentDrop.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {ERC721} from \"@openzeppelin/contracts/token/ERC721/ERC721.sol\";\nimport {Ownable} from \"@openzeppelin/contracts/access/Ownable.sol\";\nimport {ReentrancyGuard} from \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\n\ninterface IRenderer {\n    function tokenURI(uint256 id) external view returns (string memory);\n}\n\ninterface IAggregatorV3 {\n    function latestRoundData()\n        external\n        view\n        returns (uint80, int256 answer, uint256, uint256 updatedAt, uint80);\n}\n\n/// @title Agent ID-gated NFT: 10,000 supply, max 10 per wallet,\n///        first mint per wallet free, then $0.30 each paid in BNB.\ncontract AgentDrop is ERC721, Ownable, ReentrancyGuard {\n    uint256 public constant MAX_SUPPLY = 10_000;\n    uint256 public constant MAX_PER_WALLET = 10;\n    uint256 public constant FREE_PER_WALLET = 1;\n    uint256 public constant PRICE_USD_CENTS = 30; // $0.30\n\n    // BNB Chain mainnet\n    IAggregatorV3 public constant BNB_USD = IAggregatorV3(0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE); // Chainlink BNB/USD, 8 decimals\n    address public constant AGENT_ID = 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F; // Binance .ai Agent ID\n\n    uint256 public totalMinted;\n    bool public mintOpen;\n    bool public agentIdRequired = true;\n    address payable public payee;\n    string private _baseTokenURI;\n    address public renderer; // on-chain art contract; overrides baseURI when set\n\n    mapping(address => uint256) public mintedBy;\n\n    error MintClosed();\n    error NoAgentId();\n    error BadQuantity();\n    error OverLimit();\n    error SoldOut();\n    error Underpaid();\n    error StalePrice();\n    error PayFailed();\n\n    event Minted(address indexed to, uint256 firstId, uint256 quantity, uint256 paidWei);\n\n    constructor(string memory name_, string memory symbol_, string memory baseURI_, address payable payee_, address owner_)\n        ERC721(name_, symbol_)\n        Ownable(owner_)\n    {\n        _baseTokenURI = baseURI_;\n        payee = payee_;\n    }\n\n    // ---------- views ----------\n\n    function hasAgentId(address a) public view returns (bool) {\n        return ERC721(AGENT_ID).balanceOf(a) > 0;\n    }\n\n    /// @notice BNB (wei) for one paid piece at Chainlink's price.\n    function unitPriceWei() public view returns (uint256) {\n        (, int256 answer,, uint256 updatedAt,) = BNB_USD.latestRoundData();\n        if (answer <= 0 || block.timestamp - updatedAt > 1 hours) revert StalePrice();\n        // cents * 1e18 * 1e8 / (answer * 100)\n        return (PRICE_USD_CENTS * 1e24) / uint256(answer);\n    }\n\n    /// @notice Cost in wei and how many pieces are paid for `minter` minting `quantity`.\n    function quote(address minter, uint256 quantity) public view returns (uint256 costWei, uint256 paid) {\n        uint256 already = mintedBy[minter];\n        uint256 freeLeft = already >= FREE_PER_WALLET ? 0 : FREE_PER_WALLET - already;\n        paid = quantity > freeLeft ? quantity - freeLeft : 0;\n        costWei = paid == 0 ? 0 : paid * unitPriceWei();\n    }\n\n    // ---------- mint ----------\n\n    function mint(uint256 quantity) external payable nonReentrant {\n        if (!mintOpen) revert MintClosed();\n        if (agentIdRequired && !hasAgentId(msg.sender)) revert NoAgentId();\n        if (quantity == 0 || quantity > MAX_PER_WALLET) revert BadQuantity();\n        if (mintedBy[msg.sender] + quantity > MAX_PER_WALLET) revert OverLimit();\n        if (totalMinted + quantity > MAX_SUPPLY) revert SoldOut();\n\n        (uint256 cost,) = quote(msg.sender, quantity);\n        if (msg.value < cost) revert Underpaid();\n\n        mintedBy[msg.sender] += quantity;\n        uint256 first = totalMinted + 1;\n        totalMinted += quantity;\n        for (uint256 i; i < quantity; ++i) {\n            _safeMint(msg.sender, first + i);\n        }\n\n        if (cost > 0) _send(payee, cost);\n        if (msg.value > cost) _send(payable(msg.sender), msg.value - cost); // refund extra\n\n        emit Minted(msg.sender, first, quantity, cost);\n    }\n\n    // ---------- owner ----------\n\n    function setMintOpen(bool open) external onlyOwner { mintOpen = open; }\n    function setAgentIdRequired(bool required) external onlyOwner { agentIdRequired = required; }\n    function setPayee(address payable p) external onlyOwner { payee = p; }\n    function setRenderer(address r) external onlyOwner { renderer = r; }\n    function setBaseURI(string calldata uri) external onlyOwner { _baseTokenURI = uri; }\n\n    /// @notice Owner may mint up to the supply cap (e.g. for the team), free.\n    function ownerMint(address to, uint256 quantity) external onlyOwner {\n        if (totalMinted + quantity > MAX_SUPPLY) revert SoldOut();\n        uint256 first = totalMinted + 1;\n        totalMinted += quantity;\n        for (uint256 i; i < quantity; ++i) _safeMint(to, first + i);\n    }\n\n    // ---------- internal ----------\n\n    function tokenURI(uint256 id) public view override returns (string memory) {\n        if (renderer != address(0)) {\n            _requireOwned(id);\n            return IRenderer(renderer).tokenURI(id);\n        }\n        return super.tokenURI(id);\n    }\n\n    function _baseURI() internal view override returns (string memory) { return _baseTokenURI; }\n\n    function _send(address payable to, uint256 amount) private {\n        (bool ok,) = to.call{value: amount}(\"\");\n        if (!ok) revert PayFailed();\n    }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)\n\npragma solidity ^0.8.20;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../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 * The initial owner is set to the address provided by the deployer. This can\n * 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    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\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        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\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        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\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"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    /**\n     * @dev Muldiv operation overflow.\n     */\n    error MathOverflowedMulDiv();\n\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return 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 towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            return a / b;\n        }\n\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\n     * denominator == 0.\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 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 = x * y; // 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                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            if (denominator <= prod1) {\n                revert MathOverflowedMulDiv();\n            }\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.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\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\n            // works 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 (unsignedRoundsUp(rounding) && 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\n     * towards zero.\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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721} from \"./IERC721.sol\";\nimport {IERC721Receiver} from \"./IERC721Receiver.sol\";\nimport {IERC721Metadata} from \"./extensions/IERC721Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {Strings} from \"../../utils/Strings.sol\";\nimport {IERC165, ERC165} from \"../../utils/introspection/ERC165.sol\";\nimport {IERC721Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\nabstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {\n    using Strings for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    mapping(uint256 tokenId => address) private _owners;\n\n    mapping(address owner => uint256) private _balances;\n\n    mapping(uint256 tokenId => address) private _tokenApprovals;\n\n    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return\n            interfaceId == type(IERC721).interfaceId ||\n            interfaceId == type(IERC721Metadata).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev See {IERC721-balanceOf}.\n     */\n    function balanceOf(address owner) public view virtual returns (uint256) {\n        if (owner == address(0)) {\n            revert ERC721InvalidOwner(address(0));\n        }\n        return _balances[owner];\n    }\n\n    /**\n     * @dev See {IERC721-ownerOf}.\n     */\n    function ownerOf(uint256 tokenId) public view virtual returns (address) {\n        return _requireOwned(tokenId);\n    }\n\n    /**\n     * @dev See {IERC721Metadata-name}.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-symbol}.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev See {IERC721Metadata-tokenURI}.\n     */\n    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {\n        _requireOwned(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /**\n     * @dev See {IERC721-approve}.\n     */\n    function approve(address to, uint256 tokenId) public virtual {\n        _approve(to, tokenId, _msgSender());\n    }\n\n    /**\n     * @dev See {IERC721-getApproved}.\n     */\n    function getApproved(uint256 tokenId) public view virtual returns (address) {\n        _requireOwned(tokenId);\n\n        return _getApproved(tokenId);\n    }\n\n    /**\n     * @dev See {IERC721-setApprovalForAll}.\n     */\n    function setApprovalForAll(address operator, bool approved) public virtual {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /**\n     * @dev See {IERC721-isApprovedForAll}.\n     */\n    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /**\n     * @dev See {IERC721-transferFrom}.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) public virtual {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        // Setting an \"auth\" arguments enables the `_isAuthorized` check which verifies that the token exists\n        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.\n        address previousOwner = _update(to, tokenId, _msgSender());\n        if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) public {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev See {IERC721-safeTransferFrom}.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {\n        transferFrom(from, to, tokenId);\n        _checkOnERC721Received(from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     *\n     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the\n     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances\n     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by\n     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.\n     */\n    function _getApproved(uint256 tokenId) internal view virtual returns (address) {\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in\n     * particular (ignoring whether it is owned by `owner`).\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {\n        return\n            spender != address(0) &&\n            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.\n     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets\n     * the `spender` for the specific `tokenId`.\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {\n        if (!_isAuthorized(owner, spender, tokenId)) {\n            if (owner == address(0)) {\n                revert ERC721NonexistentToken(tokenId);\n            } else {\n                revert ERC721InsufficientApproval(spender, tokenId);\n            }\n        }\n    }\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that\n     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.\n     *\n     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the\n     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership\n     * remain consistent with one another.\n     */\n    function _increaseBalance(address account, uint128 value) internal virtual {\n        unchecked {\n            _balances[account] += value;\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner\n     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that\n     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.\n     */\n    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {\n        address from = _ownerOf(tokenId);\n\n        // Perform (optional) operator check\n        if (auth != address(0)) {\n            _checkAuthorized(from, auth, tokenId);\n        }\n\n        // Execute the update\n        if (from != address(0)) {\n            // Clear approval. No need to re-authorize or emit the Approval event\n            _approve(address(0), tokenId, address(0), false);\n\n            unchecked {\n                _balances[from] -= 1;\n            }\n        }\n\n        if (to != address(0)) {\n            unchecked {\n                _balances[to] += 1;\n            }\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        return from;\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner != address(0)) {\n            revert ERC721InvalidSender(address(0));\n        }\n    }\n\n    /**\n     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        _checkOnERC721Received(address(0), to, tokenId, data);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal {\n        address previousOwner = _update(address(0), tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        } else if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients\n     * are aware of the ERC721 standard to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is like {safeTransferFrom} in the sense that it invokes\n     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `tokenId` token must exist and be owned by `from`.\n     * - `to` cannot be the zero address.\n     * - `from` cannot be the zero address.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId) internal {\n        _safeTransfer(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        _checkOnERC721Received(from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is\n     * either the owner of the token, or approved to operate on all tokens held by this owner.\n     *\n     * Emits an {Approval} event.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address to, uint256 tokenId, address auth) internal {\n        _approve(to, tokenId, auth, true);\n    }\n\n    /**\n     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not\n     * emitted in the context of transfers.\n     */\n    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {\n        // Avoid reading the owner unless necessary\n        if (emitEvent || auth != address(0)) {\n            address owner = _requireOwned(tokenId);\n\n            // We do not use _isAuthorized because single-token approvals should not be able to call approve\n            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {\n                revert ERC721InvalidApprover(auth);\n            }\n\n            if (emitEvent) {\n                emit Approval(owner, to, tokenId);\n            }\n        }\n\n        _tokenApprovals[tokenId] = to;\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Requirements:\n     * - operator can't be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        if (operator == address(0)) {\n            revert ERC721InvalidOperator(operator);\n        }\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).\n     * Returns the owner.\n     *\n     * Overrides to ownership logic should be done to {_ownerOf}.\n     */\n    function _requireOwned(uint256 tokenId) internal view returns (address) {\n        address owner = _ownerOf(tokenId);\n        if (owner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n        return owner;\n    }\n\n    /**\n     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the\n     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.\n     *\n     * @param from address representing the previous owner of the given token ID\n     * @param to target address that will receive the tokens\n     * @param tokenId uint256 ID of the token to be transferred\n     * @param data bytes optional data to send along with the call\n     */\n    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {\n                if (retval != IERC721Receiver.onERC721Received.selector) {\n                    revert ERC721InvalidReceiver(to);\n                }\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    revert ERC721InvalidReceiver(to);\n                } else {\n                    /// @solidity memory-safe-assembly\n                    assembly {\n                        revert(add(32, reason), mload(reason))\n                    }\n                }\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n     *   {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard ERC20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721} from \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"}},"language":"Solidity","settings":{"optimizer":{"runs":200,"enabled":true}}},"stdJsonOutput":{"sources":{"AgentDrop.sol":{"id":13},"@openzeppelin/contracts/utils/Context.sol":{"id":6},"@openzeppelin/contracts/utils/Strings.sol":{"id":8},"@openzeppelin/contracts/access/Ownable.sol":{"id":0},"@openzeppelin/contracts/utils/math/Math.sol":{"id":11},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"id":2},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"id":3},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"id":7},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"id":12},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":1},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":9},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":10},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"id":4},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"id":5}},"contracts":{"AgentDrop.sol":{"AgentDrop":{"abi":[{"type":"constructor","inputs":[{"name":"name_","type":"string","internalType":"string"},{"name":"symbol_","type":"string","internalType":"string"},{"name":"baseURI_","type":"string","internalType":"string"},{"name":"payee_","type":"address","internalType":"address payable"},{"name":"owner_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"BadQuantity","type":"error","inputs":[]},{"name":"ERC721IncorrectOwner","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InsufficientApproval","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"ERC721InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOperator","type":"error","inputs":[{"name":"operator","type":"address","internalType":"address"}]},{"name":"ERC721InvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"ERC721InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC721InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC721NonexistentToken","type":"error","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}]},{"name":"MintClosed","type":"error","inputs":[]},{"name":"NoAgentId","type":"error","inputs":[]},{"name":"OverLimit","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"PayFailed","type":"error","inputs":[]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SoldOut","type":"error","inputs":[]},{"name":"StalePrice","type":"error","inputs":[]},{"name":"Underpaid","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"ApprovalForAll","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"operator","type":"address","indexed":true,"internalType":"address"},{"name":"approved","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Minted","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"firstId","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"quantity","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"paidWei","type":"uint256","indexed":false,"internalType":"uint256"}],"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":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"AGENT_ID","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"BNB_USD","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IAggregatorV3"}],"stateMutability":"view"},{"name":"FREE_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_PER_WALLET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PRICE_USD_CENTS","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"agentIdRequired","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"hasAgentId","type":"function","inputs":[{"name":"a","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isApprovedForAll","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"operator","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"quantity","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"name":"mintOpen","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mintedBy","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"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":"ownerMint","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"quantity","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"payee","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address payable"}],"stateMutability":"view"},{"name":"quote","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"},{"name":"quantity","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"costWei","type":"uint256","internalType":"uint256"},{"name":"paid","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"renderer","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setAgentIdRequired","type":"function","inputs":[{"name":"required","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setApprovalForAll","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"approved","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBaseURI","type":"function","inputs":[{"name":"uri","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMintOpen","type":"function","inputs":[{"name":"open","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPayee","type":"function","inputs":[{"name":"p","type":"address","internalType":"address payable"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRenderer","type":"function","inputs":[{"name":"r","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenURI","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unitPriceWei","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.24+commit.e11b9ed9\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"baseURI_\",\"type\":\"string\"},{\"internalType\":\"address payable\",\"name\":\"payee_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"owner_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"BadQuantity\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"ERC721IncorrectOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ERC721InsufficientApproval\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"approver\",\"type\":\"address\"}],\"name\":\"ERC721InvalidApprover\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"ERC721InvalidOperator\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"ERC721InvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"ERC721InvalidReceiver\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ERC721InvalidSender\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ERC721NonexistentToken\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MintClosed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoAgentId\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OverLimit\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PayFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SoldOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"StalePrice\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Underpaid\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"firstId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"quantity\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"paidWei\",\"type\":\"uint256\"}],\"name\":\"Minted\",\"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\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"AGENT_ID\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"BNB_USD\",\"outputs\":[{\"internalType\":\"contract IAggregatorV3\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FREE_PER_WALLET\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MAX_PER_WALLET\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MAX_SUPPLY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PRICE_USD_CENTS\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"agentIdRequired\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"a\",\"type\":\"address\"}],\"name\":\"hasAgentId\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"quantity\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintOpen\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"mintedBy\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"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\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quantity\",\"type\":\"uint256\"}],\"name\":\"ownerMint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"payee\",\"outputs\":[{\"internalType\":\"address payable\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"minter\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quantity\",\"type\":\"uint256\"}],\"name\":\"quote\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"costWei\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"paid\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renderer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"required\",\"type\":\"bool\"}],\"name\":\"setAgentIdRequired\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"uri\",\"type\":\"string\"}],\"name\":\"setBaseURI\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"open\",\"type\":\"bool\"}],\"name\":\"setMintOpen\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"p\",\"type\":\"address\"}],\"name\":\"setPayee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"r\",\"type\":\"address\"}],\"name\":\"setRenderer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalMinted\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unitPriceWei\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"ERC721IncorrectOwner(address,uint256,address)\":[{\"details\":\"Indicates an error related to the ownership over a particular token. Used in transfers.\",\"params\":{\"owner\":\"Address of the current owner of a token.\",\"sender\":\"Address whose tokens are being transferred.\",\"tokenId\":\"Identifier number of a token.\"}}],\"ERC721InsufficientApproval(address,uint256)\":[{\"details\":\"Indicates a failure with the `operator`’s approval. Used in transfers.\",\"params\":{\"operator\":\"Address that may be allowed to operate on tokens without being their owner.\",\"tokenId\":\"Identifier number of a token.\"}}],\"ERC721InvalidApprover(address)\":[{\"details\":\"Indicates a failure with the `approver` of a token to be approved. Used in approvals.\",\"params\":{\"approver\":\"Address initiating an approval operation.\"}}],\"ERC721InvalidOperator(address)\":[{\"details\":\"Indicates a failure with the `operator` to be approved. Used in approvals.\",\"params\":{\"operator\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"ERC721InvalidOwner(address)\":[{\"details\":\"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. Used in balance queries.\",\"params\":{\"owner\":\"Address of the current owner of a token.\"}}],\"ERC721InvalidReceiver(address)\":[{\"details\":\"Indicates a failure with the token `receiver`. Used in transfers.\",\"params\":{\"receiver\":\"Address to which tokens are being transferred.\"}}],\"ERC721InvalidSender(address)\":[{\"details\":\"Indicates a failure with the token `sender`. Used in transfers.\",\"params\":{\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC721NonexistentToken(uint256)\":[{\"details\":\"Indicates a `tokenId` whose `owner` is the zero address.\",\"params\":{\"tokenId\":\"Identifier number of a token.\"}}],\"OwnableInvalidOwner(address)\":[{\"details\":\"The owner is not a valid owner account. (eg. `address(0)`)\"}],\"OwnableUnauthorizedAccount(address)\":[{\"details\":\"The caller account is not authorized to perform an operation.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}]},\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when `owner` enables `approved` to manage the `tokenId` token.\"},\"ApprovalForAll(address,address,bool)\":{\"details\":\"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `tokenId` token is transferred from `from` to `to`.\"}},\"kind\":\"dev\",\"methods\":{\"approve(address,uint256)\":{\"details\":\"See {IERC721-approve}.\"},\"balanceOf(address)\":{\"details\":\"See {IERC721-balanceOf}.\"},\"getApproved(uint256)\":{\"details\":\"See {IERC721-getApproved}.\"},\"isApprovedForAll(address,address)\":{\"details\":\"See {IERC721-isApprovedForAll}.\"},\"name()\":{\"details\":\"See {IERC721Metadata-name}.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"ownerOf(uint256)\":{\"details\":\"See {IERC721-ownerOf}.\"},\"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.\"},\"safeTransferFrom(address,address,uint256)\":{\"details\":\"See {IERC721-safeTransferFrom}.\"},\"safeTransferFrom(address,address,uint256,bytes)\":{\"details\":\"See {IERC721-safeTransferFrom}.\"},\"setApprovalForAll(address,bool)\":{\"details\":\"See {IERC721-setApprovalForAll}.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"symbol()\":{\"details\":\"See {IERC721Metadata-symbol}.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC721-transferFrom}.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"title\":\"Agent ID-gated NFT: 10,000 supply, max 10 per wallet,        first mint per wallet free, then $0.30 each paid in BNB.\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"ownerMint(address,uint256)\":{\"notice\":\"Owner may mint up to the supply cap (e.g. for the team), free.\"},\"quote(address,uint256)\":{\"notice\":\"Cost in wei and how many pieces are paid for `minter` minting `quantity`.\"},\"unitPriceWei()\":{\"notice\":\"BNB (wei) for one paid piece at Chainlink's price.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"AgentDrop.sol\":\"AgentDrop\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"keccak256\":\"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6\",\"dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a\"]},\"@openzeppelin/contracts/interfaces/draft-IERC6093.sol\":{\"keccak256\":\"0x60c65f701957fdd6faea1acb0bb45825791d473693ed9ecb34726fdfaa849dd7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ea290300e0efc4d901244949dc4d877fd46e6c5e43dc2b26620e8efab3ab803f\",\"dweb:/ipfs/QmcLLJppxKeJWqHxE2CUkcfhuRTgHSn8J4kijcLa5MYhSt\"]},\"@openzeppelin/contracts/token/ERC721/ERC721.sol\":{\"keccak256\":\"0x13dd061770956c8489b80cfc89d9cdfc8ea2783d953691ea037a380731d52784\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ed37f0f86e7fe31659e48c3a2a5920a92dd7f13c85cf8991fb79fe5f01e08efd\",\"dweb:/ipfs/QmUtm9bQGvjr9hHGwkPWrbgFmVqzaJcxjkaYDex2oGsonS\"]},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"keccak256\":\"0x5ef46daa3b58ef2702279d514780316efaa952915ee1aa3396f041ee2982b0b4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2f8f2a76e23b02fc69e8cd24c3cb47da6c7af3a2d6c3a382f8ac25c6e094ade7\",\"dweb:/ipfs/QmPV4ZS4tPVv4mTCf9ejyZ1ai57EEibDRj7mN2ARDCLV5n\"]},\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\":{\"keccak256\":\"0x7f7a26306c79a65fb8b3b6c757cd74660c532cd8a02e165488e30027dd34ca49\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d01e0b2b837ee2f628545e54d8715b49c7ef2befd08356c2e7f6c50dde8a1c22\",\"dweb:/ipfs/QmWBAn6y2D1xgftci97Z3qR9tQnkvwQpYwFwkTvDMvqU4i\"]},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"keccak256\":\"0x37d1aaaa5a2908a09e9dcf56a26ddf762ecf295afb5964695937344fc6802ce1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ed0bfc1b92153c5000e50f4021367b931bbe96372ac6facec3c4961b72053d02\",\"dweb:/ipfs/Qmbwp8VDerjS5SV1quwHH1oMXxPQ93fzfLVqJ2RCqbowGE\"]},\"@openzeppelin/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0xf980daa263b661ab8ddee7d4fd833c7da7e7995e2c359ff1f17e67e4112f2236\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7448ab095d6940130bcf76ba47a2eab14148c83119523b93dd89f6d84edd6c02\",\"dweb:/ipfs/QmawrZ4voKQjH3oomXT3Kuheb3Mnmo2VvVpxg8Ne5UJUrd\"]},\"@openzeppelin/contracts/utils/Strings.sol\":{\"keccak256\":\"0x55f102ea785d8399c0e58d1108e2d289506dde18abc6db1b7f68c1f9f9bc5792\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6e52e0a7765c943ef14e5bcf11e46e6139fa044be564881378349236bf2e3453\",\"dweb:/ipfs/QmZEeeXoFPW47amyP35gfzomF9DixqqTEPwzBakv6cZw6i\"]},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"keccak256\":\"0x9e8778b14317ba9e256c30a76fd6c32b960af621987f56069e1e819c77c6a133\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1777404f1dcd0fac188e55a288724ec3c67b45288e49cc64723e95e702b49ab8\",\"dweb:/ipfs/QmZFdC626GButBApwDUvvTnUzdinevC3B24d7yyh57XkiA\"]},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x4296879f55019b23e135000eb36896057e7101fb7fb859c5ef690cf14643757b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://87b3541437c8c443ccd36795e56a338ed12855eec17f8da624511b8d1a7e14df\",\"dweb:/ipfs/QmeJQCtZrQjtJLr6u7ZHWeH3pBnjtLWzvRrKViAi7UZqxL\"]},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"keccak256\":\"0x005ec64c6313f0555d59e278f9a7a5ab2db5bdc72a027f255a37c327af1ec02d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4ece9f0b9c8daca08c76b6b5405a6446b6f73b3a15fab7ff56e296cbd4a2c875\",\"dweb:/ipfs/QmQyRpyPRL5SQuAgj6SHmbir3foX65FJjbVTTQrA2EFg6L\"]},\"@openzeppelin/contracts/utils/math/SignedMath.sol\":{\"keccak256\":\"0x5f7e4076e175393767754387c962926577f1660dd9b810187b9002407656be72\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7d533a1c97cd43a57cd9c465f7ee8dd0e39ae93a8fb8ff8e5303a356b081cdcc\",\"dweb:/ipfs/QmVBEei6aTnvYNZp2CHYVNKyZS4q1KkjANfY39WVXZXVoT\"]},\"AgentDrop.sol\":{\"keccak256\":\"0xa5cafd6ae3856c9c0de02ef9cab948fdc852bfa720544f3dfc77bf24525097dd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ebee5d98d13ac751577121f1b33a797902df20adbd0a9e0ca1dc9ff66333c454\",\"dweb:/ipfs/QmPqT6FwXUGsbGps8o6cawGrBSWJZF3pJh4oFaVdNkodGu\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{"unitPriceWei()":{"notice":"BNB (wei) for one paid piece at Chainlink's price."},"quote(address,uint256)":{"notice":"Cost in wei and how many pieces are paid for `minter` minting `quantity`."},"ownerMint(address,uint256)":{"notice":"Owner may mint up to the supply cap (e.g. for the team), free."}},"version":1},"devdoc":{"kind":"dev","title":"Agent ID-gated NFT: 10,000 supply, max 10 per wallet,        first mint per wallet free, then $0.30 each paid in BNB.","errors":{"ERC721InvalidOwner(address)":[{"params":{"owner":"Address of the current owner of a token."},"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. Used in balance queries."}],"ERC721InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"ERC721InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC721InvalidOperator(address)":[{"params":{"operator":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `operator` to be approved. Used in approvals."}],"ERC721InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"ERC721NonexistentToken(uint256)":[{"params":{"tokenId":"Identifier number of a token."},"details":"Indicates a `tokenId` whose `owner` is the zero address."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ERC721InsufficientApproval(address,uint256)":[{"params":{"tokenId":"Identifier number of a token.","operator":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `operator`’s approval. Used in transfers."}],"ERC721IncorrectOwner(address,uint256,address)":[{"params":{"owner":"Address of the current owner of a token.","sender":"Address whose tokens are being transferred.","tokenId":"Identifier number of a token."},"details":"Indicates an error related to the ownership over a particular token. Used in transfers."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when `owner` enables `approved` to manage the `tokenId` token."},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."},"ApprovalForAll(address,address,bool)":{"details":"Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."}},"methods":{"name()":{"details":"See {IERC721Metadata-name}."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"See {IERC721Metadata-symbol}."},"ownerOf(uint256)":{"details":"See {IERC721-ownerOf}."},"balanceOf(address)":{"details":"See {IERC721-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."},"getApproved(uint256)":{"details":"See {IERC721-getApproved}."},"approve(address,uint256)":{"details":"See {IERC721-approve}."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"setApprovalForAll(address,bool)":{"details":"See {IERC721-setApprovalForAll}."},"isApprovedForAll(address,address)":{"details":"See {IERC721-isApprovedForAll}."},"transferFrom(address,address,uint256)":{"details":"See {IERC721-transferFrom}."},"safeTransferFrom(address,address,uint256)":{"details":"See {IERC721-safeTransferFrom}."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"See {IERC721-safeTransferFrom}."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_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_address_payable":{"label":"address payable","encoding":"inplace","numberOfBytes":"20"},"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_uint256,t_address)":{"key":"t_uint256","label":"mapping(uint256 => address)","value":"t_address","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_bool))":{"key":"t_address","label":"mapping(address => mapping(address => bool))","value":"t_mapping(t_address,t_bool)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_string_storage","astId":317,"label":"_name","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"1","type":"t_string_storage","astId":319,"label":"_symbol","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"2","type":"t_mapping(t_uint256,t_address)","astId":323,"label":"_owners","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"3","type":"t_mapping(t_address,t_uint256)","astId":327,"label":"_balances","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"4","type":"t_mapping(t_uint256,t_address)","astId":331,"label":"_tokenApprovals","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"5","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":337,"label":"_operatorApprovals","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"6","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"7","type":"t_uint256","astId":1497,"label":"_status","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"8","type":"t_uint256","astId":3065,"label":"totalMinted","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"9","type":"t_bool","astId":3067,"label":"mintOpen","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"9","type":"t_bool","astId":3070,"label":"agentIdRequired","offset":1,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"9","type":"t_address_payable","astId":3072,"label":"payee","offset":2,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"10","type":"t_string_storage","astId":3074,"label":"_baseTokenURI","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"11","type":"t_address","astId":3076,"label":"renderer","offset":0,"contract":"AgentDrop.sol:AgentDrop"},{"slot":"12","type":"t_mapping(t_address,t_uint256)","astId":3080,"label":"mintedBy","offset":0,"contract":"AgentDrop.sol:AgentDrop"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"680:4715:13:-:0;;;1275:34;;;-1:-1:-1;;1275:34:13;;;;;1794:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1961:6;1929:5;1936:7;1447:5:2;:13;1929:5:13;1447::2;:13;:::i;:::-;-1:-1:-1;1470:7:2;:17;1480:7;1470;:17;:::i;:::-;-1:-1:-1;;;;;;;;1273:26:0;;1269:95;;1322:31;;-1:-1:-1;;;1322:31:0;;1350:1;1322:31;;;4899:51:14;4872:18;;1322:31:0;;;;;;;1269:95;1373:32;1392:12;1373:18;:32::i;:::-;-1:-1:-1;1713:1:7;1917:7;:21;1983:13:13::2;:24;1999:8:::0;1983:13;:24:::2;:::i;:::-;-1:-1:-1::0;;2017:5:13::2;:14:::0;;-1:-1:-1;;;;;2017:14:13;;::::2;::::0;::::2;-1:-1:-1::0;;;;;;2017:14:13;;::::2;::::0;;;::::2;::::0;;-1:-1:-1;680:4715:13;;-1:-1:-1;;680:4715:13;2912:187:0;3004:6;;;-1:-1:-1;;;;;3020:17:0;;;-1:-1:-1;;;;;;3020:17:0;;;;;;;3052:40;;3004:6;;;3020:17;3004:6;;3052:40;;2985:16;;3052:40;2975:124;2912:187;:::o;14:127:14:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:844;200:5;253:3;246:4;238:6;234:17;230:27;220:55;;271:1;268;261:12;220:55;294:13;;-1:-1:-1;;;;;356:10:14;;;353:36;;;369:18;;:::i;:::-;444:2;438:9;412:2;498:13;;-1:-1:-1;;494:22:14;;;518:2;490:31;486:40;474:53;;;542:18;;;562:22;;;539:46;536:72;;;588:18;;:::i;:::-;628:10;624:2;617:22;663:2;655:6;648:18;685:4;675:14;;732:3;725:4;720:2;712:6;708:15;704:26;701:35;698:55;;;749:1;746;739:12;698:55;771:1;762:10;;781:133;795:2;792:1;789:9;781:133;;;883:14;;;879:23;;873:30;852:14;;;848:23;;841:63;806:10;;;;781:133;;;958:1;951:4;946:2;938:6;934:15;930:26;923:37;978:6;969:15;;;;;;146:844;;;;:::o;995:139::-;-1:-1:-1;;;;;1078:31:14;;1068:42;;1058:70;;1124:1;1121;1114:12;1058:70;995:139;:::o;1139:1054::-;1283:6;1291;1299;1307;1315;1368:3;1356:9;1347:7;1343:23;1339:33;1336:53;;;1385:1;1382;1375:12;1336:53;1412:16;;-1:-1:-1;;;;;1477:14:14;;;1474:34;;;1504:1;1501;1494:12;1474:34;1527:61;1580:7;1571:6;1560:9;1556:22;1527:61;:::i;:::-;1517:71;;1634:2;1623:9;1619:18;1613:25;1597:41;;1663:2;1653:8;1650:16;1647:36;;;1679:1;1676;1669:12;1647:36;1702:63;1757:7;1746:8;1735:9;1731:24;1702:63;:::i;:::-;1692:73;;1811:2;1800:9;1796:18;1790:25;1774:41;;1840:2;1830:8;1827:16;1824:36;;;1856:1;1853;1846:12;1824:36;;1879:63;1934:7;1923:8;1912:9;1908:24;1879:63;:::i;:::-;1869:73;;;1985:2;1974:9;1970:18;1964:25;1998:39;2031:5;1998:39;:::i;:::-;2106:3;2091:19;;2085:26;2056:5;;-1:-1:-1;2120:41:14;2085:26;2120:41;:::i;:::-;2180:7;2170:17;;;1139:1054;;;;;;;;:::o;2198:380::-;2277:1;2273:12;;;;2320;;;2341:61;;2395:4;2387:6;2383:17;2373:27;;2341:61;2448:2;2440:6;2437:14;2417:18;2414:38;2411:161;;2494:10;2489:3;2485:20;2482:1;2475:31;2529:4;2526:1;2519:15;2557:4;2554:1;2547:15;2411:161;;2198:380;;;:::o;2709:518::-;2811:2;2806:3;2803:11;2800:421;;;2847:5;2844:1;2837:16;2891:4;2888:1;2878:18;2961:2;2949:10;2945:19;2942:1;2938:27;2932:4;2928:38;2997:4;2985:10;2982:20;2979:47;;;-1:-1:-1;3020:4:14;2979:47;3075:2;3070:3;3066:12;3063:1;3059:20;3053:4;3049:31;3039:41;;3130:81;3148:2;3141:5;3138:13;3130:81;;;3207:1;3193:16;;3174:1;3163:13;3130:81;;;3134:3;;2800:421;2709:518;;;:::o;3403:1345::-;3523:10;;-1:-1:-1;;;;;3545:30:14;;3542:56;;;3578:18;;:::i;:::-;3607:97;3697:6;3657:38;3689:4;3683:11;3657:38;:::i;:::-;3651:4;3607:97;:::i;:::-;3759:4;;3816:2;3805:14;;3833:1;3828:663;;;;4535:1;4552:6;4549:89;;;-1:-1:-1;4604:19:14;;;4598:26;4549:89;-1:-1:-1;;3360:1:14;3356:11;;;3352:24;3348:29;3338:40;3384:1;3380:11;;;3335:57;4651:81;;3798:944;;3828:663;2656:1;2649:14;;;2693:4;2680:18;;-1:-1:-1;;3864:20:14;;;3982:236;3996:7;3993:1;3990:14;3982:236;;;4085:19;;;4079:26;4064:42;;4177:27;;;;4145:1;4133:14;;;;4012:19;;3982:236;;;3986:3;4246:6;4237:7;4234:19;4231:201;;;4307:19;;;4301:26;-1:-1:-1;;4390:1:14;4386:14;;;4402:3;4382:24;4378:37;4374:42;4359:58;4344:74;;4231:201;;;4478:1;4469:6;4466:1;4462:14;4458:22;4452:4;4445:36;3798:944;;;;;3403:1345;;:::o;4753:203::-;680:4715:13;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"680:4715:13:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1561:300:2;;;;;;;;;;-1:-1:-1;1561:300:2;;;;;:::i;:::-;;:::i;:::-;;;565:14:14;;558:22;540:41;;528:2;513:18;1561:300:2;;;;;;;;2365:89;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3497:154::-;;;;;;;;;;-1:-1:-1;3497:154:2;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:14;;;1679:51;;1667:2;1652:18;3497:154:2;1533:203:14;3323:113:2;;;;;;;;;;-1:-1:-1;3323:113:2;;;;;:::i;:::-;;:::i;:::-;;790:43:13;;;;;;;;;;;;831:2;790:43;;;;;2343:25:14;;;2331:2;2316:18;790:43:13;2197:177:14;4143:578:2;;;;;;;;;;-1:-1:-1;4143:578:2;;;;;:::i;:::-;;:::i;1249:20:13:-;;;;;;;;;;-1:-1:-1;1249:20:13;;;;;;;;1275:34;;;;;;;;;;-1:-1:-1;1275:34:13;;;;;;;;;;;2268:330;;;;;;;;;;;;;:::i;741:43::-;;;;;;;;;;;;778:6;741:43;;1466;;;;;;;;;;-1:-1:-1;1466:43:13;;;;;:::i;:::-;;;;;;;;;;;;;;4241:70;;;;;;;;;;-1:-1:-1;4241:70:13;;;;;:::i;:::-;;:::i;4787:132:2:-;;;;;;;;;;-1:-1:-1;4787:132:2;;;;;:::i;:::-;;:::i;4558:285:13:-;;;;;;;;;;-1:-1:-1;4558:285:13;;;;;:::i;:::-;;:::i;2080:115::-;;;;;;;;;;-1:-1:-1;2080:115:13;;;;;:::i;:::-;;:::i;4389:84::-;;;;;;;;;;-1:-1:-1;4389:84:13;;;;;:::i;:::-;;:::i;4316:68::-;;;;;;;;;;-1:-1:-1;4316:68:13;;;;;:::i;:::-;;:::i;888:44::-;;;;;;;;;;;;930:2;888:44;;2185:118:2;;;;;;;;;;-1:-1:-1;2185:118:2;;;;;:::i;:::-;;:::i;1920:208::-;;;;;;;;;;-1:-1:-1;1920:208:2;;;;;:::i;:::-;;:::i;2293:101:0:-;;;;;;;;;;;;;:::i;1383:23:13:-;;;;;;;;;;-1:-1:-1;1383:23:13;;;;-1:-1:-1;;;;;1383:23:13;;;1638:85:0;;;;;;;;;;-1:-1:-1;1710:6:0;;-1:-1:-1;;;;;1710:6:0;1638:85;;2694:358:13;;;;;;;;;;-1:-1:-1;2694:358:13;;;;;:::i;:::-;;:::i;:::-;;;;4123:25:14;;;4179:2;4164:18;;4157:34;;;;4096:18;2694:358:13;3949:248:14;2518:93:2;;;;;;;;;;;;;:::i;3093:932:13:-;;;;;;:::i;:::-;;:::i;3718:144:2:-;;;;;;;;;;-1:-1:-1;3718:144:2;;;;;:::i;:::-;;:::i;1217:26:13:-;;;;;;;;;;;;;;;;1315:28;;;;;;;;;;-1:-1:-1;1315:28:13;;;;;;;-1:-1:-1;;;;;1315:28:13;;;4985:208:2;;;;;;;;;;-1:-1:-1;4985:208:2;;;;;:::i;:::-;;:::i;973:97:13:-;;;;;;;;;;;;1027:42;973:97;;4888:249;;;;;;;;;;-1:-1:-1;4888:249:13;;;;;:::i;:::-;;:::i;4143:93::-;;;;;;;;;;-1:-1:-1;4143:93:13;;;;;:::i;:::-;;:::i;839:43::-;;;;;;;;;;;;881:1;839:43;;1109:77;;;;;;;;;;;;1144:42;1109:77;;3928:153:2;;;;;;;;;;-1:-1:-1;3928:153:2;;;;;:::i;:::-;;:::i;2543:215:0:-;;;;;;;;;;-1:-1:-1;2543:215:0;;;;;:::i;:::-;;:::i;4067:71:13:-;;;;;;;;;;-1:-1:-1;4067:71:13;;;;;:::i;:::-;;:::i;1561:300:2:-;1663:4;-1:-1:-1;;;;;;1698:40:2;;-1:-1:-1;;;1698:40:2;;:104;;-1:-1:-1;;;;;;;1754:48:2;;-1:-1:-1;;;1754:48:2;1698:104;:156;;;-1:-1:-1;;;;;;;;;;861:40:9;;;1818:36:2;1679:175;1561:300;-1:-1:-1;;1561:300:2:o;2365:89::-;2410:13;2442:5;2435:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2365:89;:::o;3497:154::-;3564:7;3583:22;3597:7;3583:13;:22::i;:::-;-1:-1:-1;6008:7:2;6034:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6034:24:2;3623:21;5938:127;3323:113;3394:35;3403:2;3407:7;735:10:6;3394:8:2;:35::i;:::-;3323:113;;:::o;4143:578::-;-1:-1:-1;;;;;4237:16:2;;4233:87;;4276:33;;-1:-1:-1;;;4276:33:2;;4306:1;4276:33;;;1679:51:14;1652:18;;4276:33:2;;;;;;;;4233:87;4538:21;4562:34;4570:2;4574:7;735:10:6;4562:7:2;:34::i;:::-;4538:58;;4627:4;-1:-1:-1;;;;;4610:21:2;:13;-1:-1:-1;;;;;4610:21:2;;4606:109;;4654:50;;-1:-1:-1;;;4654:50:2;;-1:-1:-1;;;;;7986:15:14;;;4654:50:2;;;7968:34:14;8018:18;;;8011:34;;;8081:15;;8061:18;;;8054:43;7903:18;;4654:50:2;7728:375:14;4606:109:2;4223:498;4143:578;;;:::o;2268:330:13:-;2313:7;2335:13;2351:17;1027:42;-1:-1:-1;;;;;2373:23:13;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2332:66;;;;;;;2422:1;2412:6;:11;;:52;;;-1:-1:-1;2457:7:13;2427:27;2445:9;2427:15;:27;:::i;:::-;:37;2412:52;2408:77;;;2473:12;;-1:-1:-1;;;2473:12:13;;;;;;;;;;;2408:77;2584:6;2550:22;930:2;2568:4;2550:22;:::i;:::-;2549:42;;;;:::i;:::-;2542:49;;;;2268:330;:::o;4241:70::-;1531:13:0;:11;:13::i;:::-;4299:5:13::1;:9:::0;;-1:-1:-1;;;;;4299:9:13;;::::1;::::0;::::1;-1:-1:-1::0;;;;;;4299:9:13;;::::1;::::0;;;::::1;::::0;;4241:70::o;4787:132:2:-;4873:39;4890:4;4896:2;4900:7;4873:39;;;;;;;;;;;;:16;:39::i;:::-;4787:132;;;:::o;4558:285:13:-;1531:13:0;:11;:13::i;:::-;778:6:13::1;4654:8;4640:11;;:22;;;;:::i;:::-;:35;4636:57;;;4684:9;;-1:-1:-1::0;;;4684:9:13::1;;;;;;;;;;;4636:57;4703:13;4719:11;;4733:1;4719:15;;;;:::i;:::-;4703:31;;4759:8;4744:11;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;4782:9:13::1;::::0;-1:-1:-1;4777:59:13::1;4797:8;4793:1;:12;4777:59;;;4812:24;4822:2:::0;4826:9:::1;4834:1:::0;4826:5;:9:::1;:::i;:::-;4812;:24::i;:::-;4807:3;;4777:59;;2080:115:::0;2155:29;;-1:-1:-1;;;2155:29:13;;-1:-1:-1;;;;;1697:32:14;;2155:29:13;;;1679:51:14;2132:4:13;;;;1144:42;;2155:26;;1652:18:14;;2155:29:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;;2080:115;-1:-1:-1;;2080:115:13:o;4389:84::-;1531:13:0;:11;:13::i;:::-;4451::13::1;:19;4467:3:::0;;4451:13;:19:::1;:::i;4316:68::-:0;1531:13:0;:11;:13::i;:::-;4369:8:13::1;:12:::0;;-1:-1:-1;;;;;;4369:12:13::1;-1:-1:-1::0;;;;;4369:12:13;;;::::1;::::0;;;::::1;::::0;;4316:68::o;2185:118:2:-;2248:7;2274:22;2288:7;2274:13;:22::i;1920:208::-;1983:7;-1:-1:-1;;;;;2006:19:2;;2002:87;;2048:30;;-1:-1:-1;;;2048:30:2;;2075:1;2048:30;;;1679:51:14;1652:18;;2048:30:2;1533:203:14;2002:87:2;-1:-1:-1;;;;;;2105:16:2;;;;;:9;:16;;;;;;;1920:208::o;2293:101:0:-;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;2694:358:13:-;-1:-1:-1;;;;;2823:16:13;;2764:15;2823:16;;;:8;:16;;;;;;2764:15;;;881:1;2868:26;;;:58;;2901:25;2919:7;881:1;2901:25;:::i;:::-;2868:58;;;2897:1;2868:58;2849:77;;2954:8;2943;:19;:45;;2987:1;2943:45;;;2965:19;2976:8;2965;:19;:::i;:::-;2936:52;-1:-1:-1;3008:9:13;;:37;;3031:14;:12;:14::i;:::-;3024:21;;:4;:21;:::i;:::-;3008:37;;;3020:1;3008:37;2998:47;;2795:257;;2694:358;;;;;:::o;2518:93:2:-;2565:13;2597:7;2590:14;;;;;:::i;3093:932:13:-;2356:21:7;:19;:21::i;:::-;3170:8:13::1;::::0;::::1;;3165:34;;3187:12;;-1:-1:-1::0;;;3187:12:13::1;;;;;;;;;;;3165:34;3213:15;::::0;::::1;::::0;::::1;;;:42:::0;::::1;;;;3233:22;3244:10;3233;:22::i;:::-;3232:23;3213:42;3209:66;;;3264:11;;-1:-1:-1::0;;;3264:11:13::1;;;;;;;;;;;3209:66;3289:13:::0;;;:42:::1;;;831:2;3306:8;:25;3289:42;3285:68;;;3340:13;;-1:-1:-1::0;;;3340:13:13::1;;;;;;;;;;;3285:68;3376:10;3367:20;::::0;;;:8:::1;:20;::::0;;;;;831:2:::1;::::0;3367:31:::1;::::0;3390:8;;3367:31:::1;:::i;:::-;:48;3363:72;;;3424:11;;-1:-1:-1::0;;;3424:11:13::1;;;;;;;;;;;3363:72;778:6;3463:8;3449:11;;:22;;;;:::i;:::-;:35;3445:57;;;3493:9;;-1:-1:-1::0;;;3493:9:13::1;;;;;;;;;;;3445:57;3514:12;3531:27;3537:10;3549:8;3531:5;:27::i;:::-;3513:45;;;3584:4;3572:9;:16;3568:40;;;3597:11;;-1:-1:-1::0;;;3597:11:13::1;;;;;;;;;;;3568:40;3628:10;3619:20;::::0;;;:8:::1;:20;::::0;;;;:32;;3643:8;;3619:20;:32:::1;::::0;3643:8;;3619:32:::1;:::i;:::-;::::0;;;-1:-1:-1;;3677:11:13::1;::::0;3661:13:::1;::::0;3677:15:::1;::::0;3691:1:::1;3677:15;:::i;:::-;3661:31;;3717:8;3702:11;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;3740:9:13::1;::::0;-1:-1:-1;3735:92:13::1;3755:8;3751:1;:12;3735:92;;;3784:32;3794:10;3806:9;3814:1:::0;3806:5;:9:::1;:::i;3784:32::-;3765:3;;3735:92;;;-1:-1:-1::0;3841:8:13;;3837:32:::1;;3857:5;::::0;3851:18:::1;::::0;3857:5;;::::1;-1:-1:-1::0;;;;;3857:5:13::1;3864:4:::0;3851:5:::1;:18::i;:::-;3895:4;3883:9;:16;3879:66;;;3901:44;3915:10;3928:16;3940:4:::0;3928:9:::1;:16;:::i;:::-;3901:5;:44::i;:::-;3977:41;::::0;;12106:25:14;;;12162:2;12147:18;;12140:34;;;12190:18;;;12183:34;;;3984:10:13::1;::::0;3977:41:::1;::::0;12094:2:14;12079:18;3977:41:13::1;;;;;;;3155:870;;2398:20:7::0;1713:1;2924:7;:21;2744:208;2398:20;3093:932:13;:::o;3718:144:2:-;3803:52;735:10:6;3836:8:2;3846;3803:18;:52::i;4985:208::-;5098:31;5111:4;5117:2;5121:7;5098:12;:31::i;:::-;5139:47;5162:4;5168:2;5172:7;5181:4;5139:22;:47::i;4888:249:13:-;4977:8;;4948:13;;-1:-1:-1;;;;;4977:8:13;:22;4973:123;;5015:17;5029:2;5015:13;:17::i;:::-;-1:-1:-1;5063:8:13;;5053:32;;-1:-1:-1;;;5053:32:13;;;;;2343:25:14;;;-1:-1:-1;;;;;5063:8:13;;;;5053:28;;2316:18:14;;5053:32:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5053:32:13;;;;;;;;;;;;:::i;4973:123::-;5112:18;5127:2;5112:14;:18::i;4143:93::-;1531:13:0;:11;:13::i;:::-;4207:15:13::1;:26:::0;;;::::1;;;;-1:-1:-1::0;;4207:26:13;;::::1;::::0;;;::::1;::::0;;4143:93::o;3928:153:2:-;-1:-1:-1;;;;;4039:25:2;;;4016:4;4039:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;3928:153::o;2543:215:0:-;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:0;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:0;;2700:1:::1;2672:31;::::0;::::1;1679:51:14::0;1652:18;;2672:31:0::1;1533:203:14::0;2623:91:0::1;2723:28;2742:8;2723:18;:28::i;4067:71:13:-:0;1531:13:0;:11;:13::i;:::-;4120:8:13::1;:15:::0;;-1:-1:-1;;4120:15:13::1;::::0;::::1;;::::0;;;::::1;::::0;;4067:71::o;16138:241:2:-;16201:7;5799:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5799:16:2;;16263:88;;16309:31;;-1:-1:-1;;;16309:31:2;;;;;2343:25:14;;;2316:18;;16309:31:2;2197:177:14;14418:120:2;14498:33;14507:2;14511:7;14520:4;14526;14498:8;:33::i;8838:795::-;8924:7;5799:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5799:16:2;;;;9035:18;;;9031:86;;9069:37;9086:4;9092;9098:7;9069:16;:37::i;:::-;-1:-1:-1;;;;;9161:18:2;;;9157:256;;9277:48;9294:1;9298:7;9315:1;9319:5;9277:8;:48::i;:::-;-1:-1:-1;;;;;9368:15:2;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9368:20:2;;;9157:256;-1:-1:-1;;;;;9427:16:2;;;9423:107;;-1:-1:-1;;;;;9487:13:2;;;;;;:9;:13;;;;;:18;;9504:1;9487:18;;;9423:107;9540:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9540:21:2;-1:-1:-1;;;;;9540:21:2;;;;;;;;;9577:27;;9540:16;;9577:27;;;;;;;9622:4;8838:795;-1:-1:-1;;;;8838:795:2:o;1796:162:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;735:10:6;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:6;1901:40:0;;;1679:51:14;1652:18;;1901:40:0;1533:203:14;10633:100:2;10700:26;10710:2;10714:7;10700:26;;;;;;;;;;;;:9;:26::i;2912:187:0:-;3004:6;;;-1:-1:-1;;;;;3020:17:0;;;-1:-1:-1;;;;;;3020:17:0;;;;;;;3052:40;;3004:6;;;3020:17;3004:6;;3052:40;;2985:16;;3052:40;2975:124;2912:187;:::o;2431:307:7:-;1755:1;2558:7;;:18;2554:86;;2599:30;;-1:-1:-1;;;2599:30:7;;;;;;;;;;;2554:86;1755:1;2714:7;:17;2431:307::o;5241:152:13:-;5311:7;5323:2;-1:-1:-1;;;;;5323:7:13;5338:6;5323:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5310:39;;;5364:2;5359:27;;5375:11;;-1:-1:-1;;;5375:11:13;;;;;;;;;;;15591:312:2;-1:-1:-1;;;;;15698:22:2;;15694:91;;15743:31;;-1:-1:-1;;;15743:31:2;;-1:-1:-1;;;;;1697:32:14;;15743:31:2;;;1679:51:14;1652:18;;15743:31:2;1533:203:14;15694:91:2;-1:-1:-1;;;;;15794:25:2;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;15794:46:2;;;;;;;;;;15855:41;;540::14;;;15855::2;;513:18:14;15855:41:2;;;;;;;15591:312;;;:::o;16918:782::-;-1:-1:-1;;;;;17034:14:2;;;:18;17030:664;;17072:71;;-1:-1:-1;;;17072:71:2;;-1:-1:-1;;;;;17072:36:2;;;;;:71;;735:10:6;;17123:4:2;;17129:7;;17138:4;;17072:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17072:71:2;;;;;;;;-1:-1:-1;;17072:71:2;;;;;;;;;;;;:::i;:::-;;;17068:616;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17381:6;:13;17398:1;17381:18;17377:293;;17430:25;;-1:-1:-1;;;17430:25:2;;-1:-1:-1;;;;;1697:32:14;;17430:25:2;;;1679:51:14;1652:18;;17430:25:2;1533:203:14;17377:293:2;17622:6;17616:13;17607:6;17603:2;17599:15;17592:38;17068:616;-1:-1:-1;;;;;;17190:51:2;;-1:-1:-1;;;17190:51:2;17186:130;;17272:25;;-1:-1:-1;;;17272:25:2;;-1:-1:-1;;;;;1697:32:14;;17272:25:2;;;1679:51:14;1652:18;;17272:25:2;1533:203:14;17186:130:2;17144:186;16918:782;;;;:::o;2677:255::-;2741:13;2766:22;2780:7;2766:13;:22::i;:::-;;2799:21;2823:10;:8;:10::i;:::-;2799:34;;2874:1;2856:7;2850:21;:25;:75;;;;;;;;;;;;;;;;;2892:7;2901:18;:7;:16;:18::i;:::-;2878:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2850:75;2843:82;2677:255;-1:-1:-1;;;2677:255:2:o;14720:662::-;14880:9;:31;;;-1:-1:-1;;;;;;14893:18:2;;;;14880:31;14876:460;;;14927:13;14943:22;14957:7;14943:13;:22::i;:::-;14927:38;-1:-1:-1;;;;;;15093:18:2;;;;;;:35;;;15124:4;-1:-1:-1;;;;;15115:13:2;:5;-1:-1:-1;;;;;15115:13:2;;;15093:35;:69;;;;;15133:29;15150:5;15157:4;15133:16;:29::i;:::-;15132:30;15093:69;15089:142;;;15189:27;;-1:-1:-1;;;15189:27:2;;-1:-1:-1;;;;;1697:32:14;;15189:27:2;;;1679:51:14;1652:18;;15189:27:2;1533:203:14;15089:142:2;15249:9;15245:81;;;15303:7;15299:2;-1:-1:-1;;;;;15283:28:2;15292:5;-1:-1:-1;;;;;15283:28:2;;;;;;;;;;;15245:81;14913:423;14876:460;-1:-1:-1;;15346:24:2;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15346:29:2;-1:-1:-1;;;;;15346:29:2;;;;;;;;;;14720:662::o;7082:368::-;7194:38;7208:5;7215:7;7224;7194:13;:38::i;:::-;7189:255;;-1:-1:-1;;;;;7252:19:2;;7248:186;;7298:31;;-1:-1:-1;;;7298:31:2;;;;;2343:25:14;;;2316:18;;7298:31:2;2197:177:14;7248:186:2;7375:44;;-1:-1:-1;;;7375:44:2;;-1:-1:-1;;;;;14532:32:14;;7375:44:2;;;14514:51:14;14581:18;;;14574:34;;;14487:18;;7375:44:2;14340:274:14;10954:182:2;11048:18;11054:2;11058:7;11048:5;:18::i;:::-;11076:53;11107:1;11111:2;11115:7;11124:4;11076:22;:53::i;5143:92:13:-;5195:13;5219;5212:20;;;;;:::i;637:698:8:-;693:13;742:14;759:17;770:5;759:10;:17::i;:::-;779:1;759:21;742:38;;794:20;828:6;817:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;817:18:8;-1:-1:-1;794:41:8;-1:-1:-1;955:28:8;;;971:2;955:28;1010:282;-1:-1:-1;;1041:5:8;-1:-1:-1;;;1175:2:8;1164:14;;1159:32;1041:5;1146:46;1236:2;1227:11;;;-1:-1:-1;1256:21:8;1010:282;1256:21;-1:-1:-1;1312:6:8;637:698;-1:-1:-1;;;637:698:8:o;6376:272:2:-;6479:4;-1:-1:-1;;;;;6514:21:2;;;;;;:127;;;6561:7;-1:-1:-1;;;;;6552:16:2;:5;-1:-1:-1;;;;;6552:16:2;;:52;;;;6572:32;6589:5;6596:7;6572:16;:32::i;:::-;6552:88;;;-1:-1:-1;6008:7:2;6034:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6608:32:2;;;6034:24;;6608:32;6552:88;6495:146;6376:272;-1:-1:-1;;;;6376:272:2:o;9955:327::-;-1:-1:-1;;;;;10022:16:2;;10018:87;;10061:33;;-1:-1:-1;;;10061:33:2;;10091:1;10061:33;;;1679:51:14;1652:18;;10061:33:2;1533:203:14;10018:87:2;10114:21;10138:32;10146:2;10150:7;10167:1;10138:7;:32::i;:::-;10114:56;-1:-1:-1;;;;;;10184:27:2;;;10180:96;;10234:31;;-1:-1:-1;;;10234:31:2;;10262:1;10234:31;;;1679:51:14;1652:18;;10234:31:2;1533:203:14;12214:916:11;12267:7;;-1:-1:-1;;;12342:17:11;;12338:103;;-1:-1:-1;;;12379:17:11;;;-1:-1:-1;12424:2:11;12414:12;12338:103;12467:8;12458:5;:17;12454:103;;12504:8;12495:17;;;-1:-1:-1;12540:2:11;12530:12;12454:103;12583:8;12574:5;:17;12570:103;;12620:8;12611:17;;;-1:-1:-1;12656:2:11;12646:12;12570:103;12699:7;12690:5;:16;12686:100;;12735:7;12726:16;;;-1:-1:-1;12770:1:11;12760:11;12686:100;12812:7;12803:5;:16;12799:100;;12848:7;12839:16;;;-1:-1:-1;12883:1:11;12873:11;12799:100;12925:7;12916:5;:16;12912:100;;12961:7;12952:16;;;-1:-1:-1;12996:1:11;12986:11;12912:100;13038:7;13029:5;:16;13025:66;;13075:1;13065:11;13117:6;12214:916;-1:-1:-1;;12214:916:11:o;14:131:14:-;-1:-1:-1;;;;;;88:32:14;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:14;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:14;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:14:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:14;;1348:180;-1:-1:-1;1348:180:14:o;1741:131::-;-1:-1:-1;;;;;1816:31:14;;1806:42;;1796:70;;1862:1;1859;1852:12;1877:315;1945:6;1953;2006:2;1994:9;1985:7;1981:23;1977:32;1974:52;;;2022:1;2019;2012:12;1974:52;2061:9;2048:23;2080:31;2105:5;2080:31;:::i;:::-;2130:5;2182:2;2167:18;;;;2154:32;;-1:-1:-1;;;1877:315:14:o;2379:456::-;2456:6;2464;2472;2525:2;2513:9;2504:7;2500:23;2496:32;2493:52;;;2541:1;2538;2531:12;2493:52;2580:9;2567:23;2599:31;2624:5;2599:31;:::i;:::-;2649:5;-1:-1:-1;2706:2:14;2691:18;;2678:32;2719:33;2678:32;2719:33;:::i;:::-;2379:456;;2771:7;;-1:-1:-1;;;2825:2:14;2810:18;;;;2797:32;;2379:456::o;2840:247::-;2899:6;2952:2;2940:9;2931:7;2927:23;2923:32;2920:52;;;2968:1;2965;2958:12;2920:52;3007:9;2994:23;3026:31;3051:5;3026:31;:::i;3352:592::-;3423:6;3431;3484:2;3472:9;3463:7;3459:23;3455:32;3452:52;;;3500:1;3497;3490:12;3452:52;3540:9;3527:23;3569:18;3610:2;3602:6;3599:14;3596:34;;;3626:1;3623;3616:12;3596:34;3664:6;3653:9;3649:22;3639:32;;3709:7;3702:4;3698:2;3694:13;3690:27;3680:55;;3731:1;3728;3721:12;3680:55;3771:2;3758:16;3797:2;3789:6;3786:14;3783:34;;;3813:1;3810;3803:12;3783:34;3858:7;3853:2;3844:6;3840:2;3836:15;3832:24;3829:37;3826:57;;;3879:1;3876;3869:12;3826:57;3910:2;3902:11;;;;;3932:6;;-1:-1:-1;3352:592:14;;-1:-1:-1;;;;3352:592:14:o;4202:160::-;4267:20;;4323:13;;4316:21;4306:32;;4296:60;;4352:1;4349;4342:12;4296:60;4202:160;;;:::o;4367:315::-;4432:6;4440;4493:2;4481:9;4472:7;4468:23;4464:32;4461:52;;;4509:1;4506;4499:12;4461:52;4548:9;4535:23;4567:31;4592:5;4567:31;:::i;:::-;4617:5;-1:-1:-1;4641:35:14;4672:2;4657:18;;4641:35;:::i;:::-;4631:45;;4367:315;;;;;:::o;4911:127::-;4972:10;4967:3;4963:20;4960:1;4953:31;5003:4;5000:1;4993:15;5027:4;5024:1;5017:15;5043:275;5114:2;5108:9;5179:2;5160:13;;-1:-1:-1;;5156:27:14;5144:40;;5214:18;5199:34;;5235:22;;;5196:62;5193:88;;;5261:18;;:::i;:::-;5297:2;5290:22;5043:275;;-1:-1:-1;5043:275:14:o;5323:186::-;5371:4;5404:18;5396:6;5393:30;5390:56;;;5426:18;;:::i;:::-;-1:-1:-1;5492:2:14;5471:15;-1:-1:-1;;5467:29:14;5498:4;5463:40;;5323:186::o;5514:1016::-;5609:6;5617;5625;5633;5686:3;5674:9;5665:7;5661:23;5657:33;5654:53;;;5703:1;5700;5693:12;5654:53;5742:9;5729:23;5761:31;5786:5;5761:31;:::i;:::-;5811:5;-1:-1:-1;5868:2:14;5853:18;;5840:32;5881:33;5840:32;5881:33;:::i;:::-;5933:7;-1:-1:-1;5987:2:14;5972:18;;5959:32;;-1:-1:-1;6042:2:14;6027:18;;6014:32;6069:18;6058:30;;6055:50;;;6101:1;6098;6091:12;6055:50;6124:22;;6177:4;6169:13;;6165:27;-1:-1:-1;6155:55:14;;6206:1;6203;6196:12;6155:55;6242:2;6229:16;6267:48;6283:31;6311:2;6283:31;:::i;:::-;6267:48;:::i;:::-;6338:2;6331:5;6324:17;6378:7;6373:2;6368;6364;6360:11;6356:20;6353:33;6350:53;;;6399:1;6396;6389:12;6350:53;6454:2;6449;6445;6441:11;6436:2;6429:5;6425:14;6412:45;6498:1;6493:2;6488;6481:5;6477:14;6473:23;6466:34;6519:5;6509:15;;;;;5514:1016;;;;;;;:::o;6765:180::-;6821:6;6874:2;6862:9;6853:7;6849:23;6845:32;6842:52;;;6890:1;6887;6880:12;6842:52;6913:26;6929:9;6913:26;:::i;6950:388::-;7018:6;7026;7079:2;7067:9;7058:7;7054:23;7050:32;7047:52;;;7095:1;7092;7085:12;7047:52;7134:9;7121:23;7153:31;7178:5;7153:31;:::i;:::-;7203:5;-1:-1:-1;7260:2:14;7245:18;;7232:32;7273:33;7232:32;7273:33;:::i;:::-;7325:7;7315:17;;;6950:388;;;;;:::o;7343:380::-;7422:1;7418:12;;;;7465;;;7486:61;;7540:4;7532:6;7528:17;7518:27;;7486:61;7593:2;7585:6;7582:14;7562:18;7559:38;7556:161;;7639:10;7634:3;7630:20;7627:1;7620:31;7674:4;7671:1;7664:15;7702:4;7699:1;7692:15;7556:161;;7343:380;;;:::o;8108:179::-;8186:13;;8239:22;8228:34;;8218:45;;8208:73;;8277:1;8274;8267:12;8292:473;8395:6;8403;8411;8419;8427;8480:3;8468:9;8459:7;8455:23;8451:33;8448:53;;;8497:1;8494;8487:12;8448:53;8520:39;8549:9;8520:39;:::i;:::-;8510:49;;8599:2;8588:9;8584:18;8578:25;8568:35;;8643:2;8632:9;8628:18;8622:25;8612:35;;8687:2;8676:9;8672:18;8666:25;8656:35;;8710:49;8754:3;8743:9;8739:19;8710:49;:::i;:::-;8700:59;;8292:473;;;;;;;;:::o;8770:127::-;8831:10;8826:3;8822:20;8819:1;8812:31;8862:4;8859:1;8852:15;8886:4;8883:1;8876:15;8902:128;8969:9;;;8990:11;;;8987:37;;;9004:18;;:::i;9035:168::-;9108:9;;;9139;;9156:15;;;9150:22;;9136:37;9126:71;;9177:18;;:::i;9340:217::-;9380:1;9406;9396:132;;9450:10;9445:3;9441:20;9438:1;9431:31;9485:4;9482:1;9475:15;9513:4;9510:1;9503:15;9396:132;-1:-1:-1;9542:9:14;;9340:217::o;9562:125::-;9627:9;;;9648:10;;;9645:36;;;9661:18;;:::i;9692:184::-;9762:6;9815:2;9803:9;9794:7;9790:23;9786:32;9783:52;;;9831:1;9828;9821:12;9783:52;-1:-1:-1;9854:16:14;;9692:184;-1:-1:-1;9692:184:14:o;10007:518::-;10109:2;10104:3;10101:11;10098:421;;;10145:5;10142:1;10135:16;10189:4;10186:1;10176:18;10259:2;10247:10;10243:19;10240:1;10236:27;10230:4;10226:38;10295:4;10283:10;10280:20;10277:47;;;-1:-1:-1;10318:4:14;10277:47;10373:2;10368:3;10364:12;10361:1;10357:20;10351:4;10347:31;10337:41;;10428:81;10446:2;10439:5;10436:13;10428:81;;;10505:1;10491:16;;10472:1;10461:13;10428:81;;10701:1198;10825:18;10820:3;10817:27;10814:53;;;10847:18;;:::i;:::-;10876:94;10966:3;10926:38;10958:4;10952:11;10926:38;:::i;:::-;10920:4;10876:94;:::i;:::-;10996:1;11021:2;11016:3;11013:11;11038:1;11033:608;;;;11685:1;11702:3;11699:93;;;-1:-1:-1;11758:19:14;;;11745:33;11699:93;-1:-1:-1;;10658:1:14;10654:11;;;10650:24;10646:29;10636:40;10682:1;10678:11;;;10633:57;11805:78;;11006:887;;11033:608;9954:1;9947:14;;;9991:4;9978:18;;-1:-1:-1;;11069:17:14;;;11184:229;11198:7;11195:1;11192:14;11184:229;;;11287:19;;;11274:33;11259:49;;11394:4;11379:20;;;;11347:1;11335:14;;;;11214:12;11184:229;;;11188:3;11441;11432:7;11429:16;11426:159;;;11565:1;11561:6;11555:3;11549;11546:1;11542:11;11538:21;11534:34;11530:39;11517:9;11512:3;11508:19;11495:33;11491:79;11483:6;11476:95;11426:159;;;11628:1;11622:3;11619:1;11615:11;11611:19;11605:4;11598:33;11006:887;;10701:1198;;;:::o;12228:648::-;12308:6;12361:2;12349:9;12340:7;12336:23;12332:32;12329:52;;;12377:1;12374;12367:12;12329:52;12410:9;12404:16;12443:18;12435:6;12432:30;12429:50;;;12475:1;12472;12465:12;12429:50;12498:22;;12551:4;12543:13;;12539:27;-1:-1:-1;12529:55:14;;12580:1;12577;12570:12;12529:55;12609:2;12603:9;12634:48;12650:31;12678:2;12650:31;:::i;12634:48::-;12705:2;12698:5;12691:17;12745:7;12740:2;12735;12731;12727:11;12723:20;12720:33;12717:53;;;12766:1;12763;12756:12;12717:53;12779:67;12843:2;12838;12831:5;12827:14;12822:2;12818;12814:11;12779:67;:::i;:::-;12865:5;12228:648;-1:-1:-1;;;;;12228:648:14:o;13091:489::-;-1:-1:-1;;;;;13360:15:14;;;13342:34;;13412:15;;13407:2;13392:18;;13385:43;13459:2;13444:18;;13437:34;;;13507:3;13502:2;13487:18;;13480:31;;;13285:4;;13528:46;;13554:19;;13546:6;13528:46;:::i;:::-;13520:54;13091:489;-1:-1:-1;;;;;;13091:489:14:o;13585:249::-;13654:6;13707:2;13695:9;13686:7;13682:23;13678:32;13675:52;;;13723:1;13720;13713:12;13675:52;13755:9;13749:16;13774:30;13798:5;13774:30;:::i;13839:496::-;14018:3;14056:6;14050:13;14072:66;14131:6;14126:3;14119:4;14111:6;14107:17;14072:66;:::i;:::-;14201:13;;14160:16;;;;14223:70;14201:13;14160:16;14270:4;14258:17;;14223:70;:::i;:::-;14309:20;;13839:496;-1:-1:-1;;;;13839:496:14:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"AGENT_ID()","signatureHash4":"0xe905182a","signatureHash32":"0xe905182a993255e78bd6a13d8f90af94e098654f889eb14905fb91c8d73237a3"},{"signature":"agentIdRequired()","signatureHash4":"0x2b7da1ec","signatureHash32":"0x2b7da1ecd3bbed6d143b3c7593aa3f4b3d251140718b613bcb3f7f324dbb7add"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"BNB_USD()","signatureHash4":"0xc2178267","signatureHash32":"0xc21782671ea3a5c1088d264001c4f2d4b5eaee3460629af4dcdea8db563c7e49"},{"signature":"FREE_PER_WALLET()","signatureHash4":"0xcd90e5af","signatureHash32":"0xcd90e5af7c66183314b1f787317384e163b5fd5f3761c1a6fa675d75d5f9e35e"},{"signature":"getApproved(uint256)","signatureHash4":"0x081812fc","signatureHash32":"0x081812fc55e34fdc7cf5d8b5cf4e3621fa6423fde952ec6ab24afdc0d85c0b2e"},{"signature":"hasAgentId(address)","signatureHash4":"0x4eab3ef2","signatureHash32":"0x4eab3ef2fa23cba79252762797184b21c85f705a6b8f7d2ce3917152642d3ec9"},{"signature":"isApprovedForAll(address,address)","signatureHash4":"0xe985e9c5","signatureHash32":"0xe985e9c5c6636c6879256001057b28ccac7718ef0ac56553ff9b926452cab8a3"},{"signature":"MAX_PER_WALLET()","signatureHash4":"0x0f2cdd6c","signatureHash32":"0x0f2cdd6cd2d6b96a106f015e0c005331df6139f3a1c34460fde7b644b1ae8e68"},{"signature":"MAX_SUPPLY()","signatureHash4":"0x32cb6b0c","signatureHash32":"0x32cb6b0c9d125b1472513cbeeb7f75e981364c137d7d7140f52eb5e4e9cbb979"},{"signature":"mintedBy(address)","signatureHash4":"0x3cef28d2","signatureHash32":"0x3cef28d2a347eb7b15200f788ef3c7d0d847423cdf0ff5ffe4229b4ce296ca90"},{"signature":"mintOpen()","signatureHash4":"0x24bbd049","signatureHash32":"0x24bbd049b398cb3c8e328beccb6e7271655b0e9711e6216d7d3a382fa2eb29ff"},{"signature":"mint(uint256)","signatureHash4":"0xa0712d68","signatureHash32":"0xa0712d680358d64f694230b7cc0b277c73686bdf768385d55cd7c547d0ffd30e"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"ownerMint(address,uint256)","signatureHash4":"0x484b973c","signatureHash32":"0x484b973c9c8bdd054f6fa66227be35454cdac7edb3069a635dda5e5cc738ca62"},{"signature":"ownerOf(uint256)","signatureHash4":"0x6352211e","signatureHash32":"0x6352211e6566aa027e75ac9dbf2423197fbd9b82b9d981a3ab367d355866aa1c"},{"signature":"payee()","signatureHash4":"0xae90b213","signatureHash32":"0xae90b213dad969d0548bb9571dd3783b20552258747f95779714f52a3b6f324d"},{"signature":"PRICE_USD_CENTS()","signatureHash4":"0x599e8bb5","signatureHash32":"0x599e8bb5c14e8f82a5d51c8cb1478c0a6d7dfbc1829595b62f8c03c03129a33f"},{"signature":"quote(address,uint256)","signatureHash4":"0x8f79306e","signatureHash32":"0x8f79306e7dbee0a4dbf3bdc8d8107cf7e7a1ed4e2b28094d37fac66d86ae910f"},{"signature":"renderer()","signatureHash4":"0x8ada6b0f","signatureHash32":"0x8ada6b0fefa976d7d1a5131e4e3215cf3a2e9e7134e9c91c925097c738631e5e"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"safeTransferFrom(address,address,uint256)","signatureHash4":"0x42842e0e","signatureHash32":"0x42842e0eb38857a7775b4e7364b2775df7325074d088e7fb39590cd6281184ed"},{"signature":"safeTransferFrom(address,address,uint256,bytes)","signatureHash4":"0xb88d4fde","signatureHash32":"0xb88d4fde60196325a28bb7f99a2582e0b46de55b18761e960c14ad7a32099465"},{"signature":"setAgentIdRequired(bool)","signatureHash4":"0xc9c64ddb","signatureHash32":"0xc9c64ddb837eb34cd6f347b5fa0a24029688c2bf4e0c306f36bd3c8acaf01a11"},{"signature":"setApprovalForAll(address,bool)","signatureHash4":"0xa22cb465","signatureHash32":"0xa22cb4651ab9570f89bb516380c40ce76762284fb1f21337ceaf6adab99e7d4a"},{"signature":"setBaseURI(string)","signatureHash4":"0x55f804b3","signatureHash32":"0x55f804b373ab21b346f6f172ca5e118cfcad05163bcea59b35420499bf7e074b"},{"signature":"setMintOpen(bool)","signatureHash4":"0xf8004d31","signatureHash32":"0xf8004d31b84b5f19ac0cf522f7f0bc19d42a65b8f199e640c1670b5de5f6dfea"},{"signature":"setPayee(address)","signatureHash4":"0x410459ad","signatureHash32":"0x410459ad9e4bb99a9d1d729c0f845dee3a492d912889c9da813a801531d9ca52"},{"signature":"setRenderer(address)","signatureHash4":"0x56d3163d","signatureHash32":"0x56d3163db7e1160f52af64cc3ef22d671de4131c24b74164a7d4bca178be196b"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"tokenURI(uint256)","signatureHash4":"0xc87b56dd","signatureHash32":"0xc87b56dda752230262935940d907f047a9f86bb5ee6aa33511fc86db33fea6cc"},{"signature":"totalMinted()","signatureHash4":"0xa2309ff8","signatureHash32":"0xa2309ff8a1f86a4fb15fe22cc66ca2240889c22973a8705ca226daf66b420ca7"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"unitPriceWei()","signatureHash4":"0x32b5ea50","signatureHash32":"0x32b5ea509dd63dc524094156e8121dfbbab36e922e31756c1e78eba2ecbc0d08"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"ApprovalForAll(address,address,bool)","signatureHash4":"0x17307eab","signatureHash32":"0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31"},{"signature":"Minted(address,uint256,uint256,uint256)","signatureHash4":"0x5a3358a3","signatureHash32":"0x5a3358a3d27a5373c0df2604662088d37894d56b7cfd27f315770440f4e0d919"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[{"signature":"BadQuantity()","signatureHash4":"0x888e58a8","signatureHash32":"0x888e58a81e368269cdd5d2b48d01fb2706631f15b090811dab6bfa16f8decf77"},{"signature":"ERC721IncorrectOwner(address,uint256,address)","signatureHash4":"0x64283d7b","signatureHash32":"0x64283d7b313c8117c125f736876fa2b4e90ea3831a4716dfdb87d2f540e26289"},{"signature":"ERC721InsufficientApproval(address,uint256)","signatureHash4":"0x177e802f","signatureHash32":"0x177e802f6f313bc89797ecace66d6d29ab4719cbaaacbb87367264048b1eb861"},{"signature":"ERC721InvalidApprover(address)","signatureHash4":"0xa9fbf51f","signatureHash32":"0xa9fbf51f86b8e03595d59dc726bb10c329bb24f62589be276d8dd193ca0b69ea"},{"signature":"ERC721InvalidOperator(address)","signatureHash4":"0x5b08ba18","signatureHash32":"0x5b08ba185e8f577075361f3a3555a6580a227ce22734dcc979c1aeadf894658b"},{"signature":"ERC721InvalidOwner(address)","signatureHash4":"0x89c62b64","signatureHash32":"0x89c62b6479af2e623826dcc39c5133061d35b66d72de92833401dd2fd6567480"},{"signature":"ERC721InvalidReceiver(address)","signatureHash4":"0x64a0ae92","signatureHash32":"0x64a0ae9278f805eaf991dcd18ca78756d280b7508b764ef1b255c55845c11df9"},{"signature":"ERC721InvalidSender(address)","signatureHash4":"0x73c6ac6e","signatureHash32":"0x73c6ac6e10798e95d99e1f130d923eb40193ecb8d094ec3dce93292564eb3b17"},{"signature":"ERC721NonexistentToken(uint256)","signatureHash4":"0x7e273289","signatureHash32":"0x7e273289a3a9ef6670f06df7dca227856fc925e956db96980692764a8bc734d7"},{"signature":"MintClosed()","signatureHash4":"0x589ed34b","signatureHash32":"0x589ed34b6de61e6df418b1c0e5caa881461804657f37544ca23bf0b86d09f1e3"},{"signature":"NoAgentId()","signatureHash4":"0xf947691f","signatureHash32":"0xf947691f20148f7edaa4630017d1cbba1e31645b2aebbf26b3829f4d6bf35815"},{"signature":"OverLimit()","signatureHash4":"0xb92612ed","signatureHash32":"0xb92612ed3aca266577a1ff8e6f36b8361b2aa4da4a36df987bc0da99a6a932d7"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"},{"signature":"PayFailed()","signatureHash4":"0x197121f5","signatureHash32":"0x197121f5e3e9b0a89237395d4fa57597aeba07fdc9b8ee7df3e1d733b3ae247d"},{"signature":"ReentrancyGuardReentrantCall()","signatureHash4":"0x3ee5aeb5","signatureHash32":"0x3ee5aeb571de7fc460830b4d0017439a1ca56fb0bc39062227ade4fe4a24c1ca"},{"signature":"SoldOut()","signatureHash4":"0x52df9fe5","signatureHash32":"0x52df9fe5b9c9a7b0b4fdc2c9f89387959e35e4209c2a8d133a2b8165edad2a04"},{"signature":"StalePrice()","signatureHash4":"0x19abf40e","signatureHash32":"0x19abf40e7c2e0280d6137a5d95d9f3793d913552f00d0e25e4ab4388bcc0d573"},{"signature":"Underpaid()","signatureHash4":"0x949ce241","signatureHash32":"0x949ce241d82d496394624e3d0858444ee23c56488a8347ab62eae53da5f7fb5e"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0x4A15F38c75E529205a45BD2eE57c02AFAB2F6569"}