{"matchId":"57371584","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-10-28T10:04:22Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1155:6329:17:-:0;;;3007:870;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3274:10;1380:113:3;;;;;;;;;;;;;-1:-1:-1;;;1380:113:3;;;;;;;;;;;;;;;;-1:-1:-1;;;1380:113:3;;;1454:5;1446;:13;;;;;;:::i;:::-;-1:-1:-1;1469:7:3;:17;1479:7;1469;:17;:::i;:::-;-1:-1:-1;;;;;;;;1273:26:0;;1269:95;;1322:31;;-1:-1:-1;;;1322:31:0;;1350:1;1322:31;;;4810:51:18;4783:18;;1322:31:0;;;;;;;;1269:95;1373:32;1392:12;1373:18;:32::i;:::-;-1:-1:-1;;;;;;3300:23:17;::::2;3296:49;;3332:13;;-1:-1:-1::0;;;3332:13:17::2;;;;;;;;;;;3296:49;3359:15:::0;;;:40:::2;;;3389:10;3378:8;:21;3359:40;:62;;;-1:-1:-1::0;3403:18:17;;3359:62:::2;:80;;;-1:-1:-1::0;3425:14:17;;3359:80:::2;:102;;;;3452:9;3443:6;:18;3359:102;3355:126;;;3470:11;;-1:-1:-1::0;;;3470:11:17::2;;;;;;;;;;;3355:126;-1:-1:-1::0;;;;;3491:20:17;::::2;;::::0;3513:22:::2;::::0;;;-1:-1:-1;3537:28:17;;;3567:20:::2;::::0;;;3597:18:::2;::::0;;;3617:5:::2;:14:::0;;;3633:20:::2;::::0;;;3655:8:::2;:16;3666:5:::0;3655:8;:16:::2;:::i;:::-;-1:-1:-1::0;3673:12:17::2;:28;3688:13:::0;3673:12;:28:::2;:::i;:::-;-1:-1:-1::0;3728:1:17::2;3711:60;3736:8;3731:1;:13;3711:60;;3751:20;3757:10;3769:1:::0;3751:5:::2;:20::i;:::-;3746:3:::0;::::2;::::0;::::2;:::i;:::-;;;;3711:60;;;-1:-1:-1::0;3781:11:17::2;:22:::0;;;3817:12;;3813:57:::2;;3836:34;::::0;;3855:1:::2;5327:25:18::0;;5383:2;5368:18;;5361:34;;;-1:-1:-1;5411:18:18;;;5404:34;3836::17;;3843:10:::2;::::0;3836:34:::2;::::0;;;;;5315:2:18;3836:34:17;;::::2;3813:57;3007:870:::0;;;;;;;;;1155:6329;;2011:153:1;2100:13;2093:20;;-1:-1:-1;;;;;;2093:20:1;;;2123:34;2148:8;2123:24;:34::i;:::-;2011:153;:::o;9624:327:3:-;-1:-1:-1;;;;;9691:16:3;;9687:87;;9730:33;;-1:-1:-1;;;9730:33:3;;9760:1;9730:33;;;4810:51:18;4783:18;;9730:33:3;4664:203:18;9687:87:3;9783:21;9807:32;9815:2;9819:7;9783:21;9807:7;:32::i;:::-;9783:56;-1:-1:-1;;;;;;9853:27:3;;;9849:96;;9903:31;;-1:-1:-1;;;9903:31:3;;9931:1;9903:31;;;4810:51:18;4783:18;;9903:31:3;4664:203:18;9849:96:3;9677:274;9624:327;;:::o;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;8507:795:3:-;8593:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:3;;;;8704:18;;;8700:86;;8738:37;8755:4;8761;8767:7;8738:16;:37::i;:::-;-1:-1:-1;;;;;8830:18:3;;;8826:256;;8946:48;8963:1;8967:7;8963:1;;8946:8;:48::i;:::-;-1:-1:-1;;;;;9037:15:3;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9037:20:3;;;8826:256;-1:-1:-1;;;;;9096:16:3;;;9092:107;;-1:-1:-1;;;;;9156:13:3;;;;;;:9;:13;;;;;:18;;9173:1;9156:18;;;9092:107;9209:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9209:21:3;-1:-1:-1;;;;;9209:21:3;;;;;;;;;9246:27;;9209:16;;9246:27;;;;;;;9291:4;8507:795;-1:-1:-1;;;;8507:795:3:o;6751:368::-;6863:38;6877:5;6884:7;6893;6863:13;:38::i;:::-;6858:255;;-1:-1:-1;;;;;6921:19:3;;6917:186;;6967:31;;-1:-1:-1;;;6967:31:3;;;;;5595:25:18;;;5568:18;;6967:31:3;5449:177:18;6917:186:3;7044:44;;-1:-1:-1;;;7044:44:3;;-1:-1:-1;;;;;5823:32:18;;7044:44:3;;;5805:51:18;5872:18;;;5865:34;;;5778:18;;7044:44:3;5631:274:18;14440:662:3;14600:9;:31;;;-1:-1:-1;;;;;;14613:18:3;;;;14600:31;14596:460;;;14647:13;14663:22;14677:7;14663:13;:22::i;:::-;14647:38;-1:-1:-1;;;;;;14813:18:3;;;;;;:35;;;14844:4;-1:-1:-1;;;;;14835:13:3;:5;-1:-1:-1;;;;;14835:13:3;;;14813:35;:69;;;;-1:-1:-1;;;;;;3776:25:3;;;3753:4;3776:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;14852:30;14813:69;14809:142;;;14909:27;;-1:-1:-1;;;14909:27:3;;-1:-1:-1;;;;;4828:32:18;;14909:27:3;;;4810:51:18;4783:18;;14909:27:3;4664:203:18;14809:142:3;14969:9;14965:81;;;15023:7;15019:2;-1:-1:-1;;;;;15003:28:3;15012:5;-1:-1:-1;;;;;15003:28:3;;;;;;;;;;;14965:81;14633:423;14596:460;-1:-1:-1;;15066:24:3;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15066:29:3;-1:-1:-1;;;;;15066:29:3;;;;;;;;;;14440:662::o;6047:272::-;6150:4;-1:-1:-1;;;;;6185:21:3;;;;;;:127;;;6232:7;-1:-1:-1;;;;;6223:16:3;:5;-1:-1:-1;;;;;6223:16:3;;:52;;;-1:-1:-1;;;;;;3776:25:3;;;3753:4;3776:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;6243:32;6223:88;;;-1:-1:-1;5679:7:3;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6279:32:3;;;5705:24;;6279:32;6223:88;6166:146;6047:272;-1:-1:-1;;;;6047:272:3:o;15957:241::-;16020:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:3;;16082:88;;16128:31;;-1:-1:-1;;;16128:31:3;;;;;5595:25:18;;;5568:18;;16128:31:3;5449:177:18;16082:88:3;16186:5;15957:241;-1:-1:-1;;15957:241:3:o;14:127:18:-;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:18;;;353:36;;;369:18;;:::i;:::-;444:2;438:9;412:2;498:13;;-1:-1:-1;;494:22:18;;;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:1109::-;1165:6;1173;1181;1189;1197;1205;1213;1221;1229;1282:3;1270:9;1261:7;1257:23;1253:33;1250:53;;;1299:1;1296;1289:12;1250:53;1325:16;;-1:-1:-1;;;;;1370:31:18;;1360:42;;1350:70;;1416:1;1413;1406:12;1350:70;1439:5;1429:15;;;1484:2;1473:9;1469:18;1463:25;1453:35;;1528:2;1517:9;1513:18;1507:25;1497:35;;1572:2;1561:9;1557:18;1551:25;1541:35;;1616:3;1605:9;1601:19;1595:26;1585:36;;1661:3;1650:9;1646:19;1640:26;1630:36;;1706:3;1695:9;1691:19;1685:26;1675:36;;1755:3;1744:9;1740:19;1734:26;1795:1;1791;1787:2;1783:10;1779:18;1820:2;1812:6;1809:14;1806:34;;;1836:1;1833;1826:12;1806:34;1859:61;1912:7;1903:6;1892:9;1888:22;1859:61;:::i;:::-;1849:71;;1966:3;1955:9;1951:19;1945:26;1929:42;;1996:2;1986:8;1983:16;1980:36;;;2012:1;2009;2002:12;1980:36;;2035:63;2090:7;2079:8;2068:9;2064:24;2035:63;:::i;:::-;2025:73;;;995:1109;;;;;;;;;;;:::o;2109:380::-;2188:1;2184:12;;;;2231;;;2252:61;;2306:4;2298:6;2294:17;2284:27;;2252:61;2359:2;2351:6;2348:14;2328:18;2325:38;2322:161;;2405:10;2400:3;2396:20;2393:1;2386:31;2440:4;2437:1;2430:15;2468:4;2465:1;2458:15;2322:161;;2109:380;;;:::o;2620:518::-;2722:2;2717:3;2714:11;2711:421;;;2758:5;2755:1;2748:16;2802:4;2799:1;2789:18;2872:2;2860:10;2856:19;2853:1;2849:27;2843:4;2839:38;2908:4;2896:10;2893:20;2890:47;;;-1:-1:-1;2931:4:18;2890:47;2986:2;2981:3;2977:12;2974:1;2970:20;2964:4;2960:31;2950:41;;3041:81;3059:2;3052:5;3049:13;3041:81;;;3118:1;3104:16;;3085:1;3074:13;3041:81;;;3045:3;;2620:518;;;:::o;3314:1345::-;3434:10;;-1:-1:-1;;;;;3456:30:18;;3453:56;;;3489:18;;:::i;:::-;3518:97;3608:6;3568:38;3600:4;3594:11;3568:38;:::i;:::-;3562:4;3518:97;:::i;:::-;3670:4;;3727:2;3716:14;;3744:1;3739:663;;;;4446:1;4463:6;4460:89;;;-1:-1:-1;4515:19:18;;;4509:26;4460:89;-1:-1:-1;;3271:1:18;3267:11;;;3263:24;3259:29;3249:40;3295:1;3291:11;;;3246:57;4562:81;;3709:944;;3739:663;2567:1;2560:14;;;2604:4;2591:18;;-1:-1:-1;;3775:20:18;;;3893:236;3907:7;3904:1;3901:14;3893:236;;;3996:19;;;3990:26;3975:42;;4088:27;;;;4056:1;4044:14;;;;3923:19;;3893:236;;;3897:3;4157:6;4148:7;4145:19;4142:201;;;4218:19;;;4212:26;-1:-1:-1;;4301:1:18;4297:14;;;4313:3;4293:24;4289:37;4285:42;4270:58;4255:74;;4142:201;;;4389:1;4380:6;4377:1;4373:14;4369:22;4363:4;4356:36;3709:944;;;;;3314:1345;;:::o;4872:232::-;4911:3;4932:17;;;4929:140;;4991:10;4986:3;4982:20;4979:1;4972:31;5026:4;5023:1;5016:15;5054:4;5051:1;5044:15;4929:140;-1:-1:-1;5096:1:18;5085:13;;4872:232::o;5631:274::-;1155:6329:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220147e78fa91f21765b0e050c8d20867827c0cd07f6a53ccb37271e9d4e2348ae664736f6c63430008180033","offset":9970}},"transformations":[{"type":"insert","offset":10023,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000f38131a439d885b274731bbed2688b03cdcad13200000000000000000000000000000000000000000000000000000000000015b3000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002615c87ffe00000000000000000000000000000000000000000000000000000071afd498d000000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000002868747470733a2f2f636f6769746f6167656e74732e70616765732e6465762f6d657461646174612f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002c68747470733a2f2f636f6769746f6167656e74732e70616765732e6465762f636f6e74726163742e6a736f6e0000000000000000000000000000000000000000"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1155:6329:17:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7236:153;;;;;;;;;;-1:-1:-1;7236:153:17;;;;;:::i;:::-;;:::i;:::-;;;565:14:18;;558:22;540:41;;528:2;513:18;7236:153:17;;;;;;;;2263:89:3;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3299:154::-;;;;;;;;;;-1:-1:-1;3299:154:3;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:18;;;1679:51;;1667:2;1652:18;3299:154:3;1533:203:18;3152:113:3;;;;;;;;;;-1:-1:-1;3152:113:3;;;;;:::i;:::-;;:::i;:::-;;2001:26:17;;;;;;;;;;;;;;;;;;;2324:25:18;;;2312:2;2297:18;2001:26:17;2178:177:18;3852:578:3;;;;;;;;;;-1:-1:-1;3852:578:3;;;;;:::i;:::-;;:::i;6375:213:17:-;;;;;;;;;;;;;:::i;2106:43::-;;;;;;;;;;-1:-1:-1;2106:43:17;;;;;:::i;:::-;;;;;;;;;;;;;;4464:132:3;;;;;;;;;;-1:-1:-1;4464:132:3;;;;;:::i;:::-;;:::i;1361:37:17:-;;;;;;;;;;;;;;;5697:88;;;;;;;;;;;;;:::i;6683:252::-;;;;;;;;;;-1:-1:-1;6683:252:17;;;;;:::i;:::-;;:::i;1777:41::-;;;;;;;;;;;;;;;2103:118:3;;;;;;;;;;-1:-1:-1;2103:118:3;;;;;:::i;:::-;;:::i;1861:208::-;;;;;;;;;;-1:-1:-1;1861:208:3;;;;;:::i;:::-;;:::i;2293:101:0:-;;;;;;;;;;;;;:::i;2244:229:1:-;;;;;;;;;;;;;:::i;1638:85:0:-;;;;;;;;;;-1:-1:-1;1710:6:0;;-1:-1:-1;;;;;1710:6:0;1638:85;;6122:160:17;;;;;;;;;;-1:-1:-1;6122:160:17;;;;;:::i;:::-;;:::i;2394:93:3:-;;;;;;;;;;;;;:::i;1908:20:17:-;;;;;;;;;;;;;;;;4325:624;;;;;;:::i;:::-;;:::i;3487:144:3:-;;;;;;;;;;-1:-1:-1;3487:144:3;;;;;:::i;:::-;;:::i;4630:233::-;;;;;;;;;;-1:-1:-1;4630:233:3;;;;;:::i;:::-;;:::i;2529:255::-;;;;;;;;;;-1:-1:-1;2529:255:3;;;;;:::i;:::-;;:::i;1580:32:17:-;;;;;;;;;;;;;;;7003:177;;;;;;;;;;;;;:::i;1249:34::-;;;;;;;;;;;;;;;5545:93;;;;;;;;;;-1:-1:-1;5545:93:17;;;;;:::i;:::-;-1:-1:-1;;;;;5617:13:17;5602:4;5617:13;;;:8;:13;;;;;;:18;;5545:93;1232:99:1;;;;;;;;;;-1:-1:-1;1311:13:1;;-1:-1:-1;;;;;1311:13:1;1232:99;;1685:33:17;;;;;;;;;;;;;;;5919:85;;;;;;;;;;;;;:::i;3665:153:3:-;;;;;;;;;;-1:-1:-1;3665:153:3;;;;;:::i;:::-;;:::i;1649:178:1:-;;;;;;;;;;-1:-1:-1;1649:178:1;;;;;:::i;:::-;;:::i;5308:156:17:-;;;;;;;;;;-1:-1:-1;5308:156:17;;;;;:::i;:::-;;:::i;1446:33::-;;;;;;;;;;;;;;;2276:26;;;;;;;;;;-1:-1:-1;2276:26:17;;;;;;;;7236:153;7304:4;-1:-1:-1;;;;;;7327:24:17;;-1:-1:-1;;;7327:24:17;;:55;;;7355:27;7379:2;7355:23;:27::i;:::-;7320:62;7236:153;-1:-1:-1;;7236:153:17:o;2263:89:3:-;2308:13;2340:5;2333:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2263:89;:::o;3299:154::-;3366:7;3385:22;3399:7;3385:13;:22::i;:::-;-1:-1:-1;5679:7:3;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;5705:24:3;3425:21;5609:127;3152:113;3223:35;3232:2;3236:7;735:10:9;3223:8:3;:35::i;:::-;3152:113;;:::o;3852:578::-;-1:-1:-1;;;;;3946:16:3;;3942:87;;3985:33;;-1:-1:-1;;;3985:33:3;;4015:1;3985:33;;;1679:51:18;1652:18;;3985:33:3;;;;;;;;3942:87;4247:21;4271:34;4279:2;4283:7;735:10:9;4271:7:3;:34::i;:::-;4247:58;;4336:4;-1:-1:-1;;;;;4319:21:3;:13;-1:-1:-1;;;;;4319:21:3;;4315:109;;4363:50;;-1:-1:-1;;;4363:50:3;;-1:-1:-1;;;;;6240:15:18;;;4363:50:3;;;6222:34:18;6272:18;;;6265:34;;;6335:15;;6315:18;;;6308:43;6157:18;;4363:50:3;5982:375:18;4315:109:3;3932:498;3852:578;;;:::o;6375:213:17:-;6473:29;;6428:21;;6414:11;;-1:-1:-1;;;;;6473:8:17;:13;;6428:21;;6414:11;6473:29;6414:11;6473:29;6428:21;6473:13;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6459:43;;;6520:2;6512:30;;;;-1:-1:-1;;;6512:30:17;;6774:2:18;6512:30:17;;;6756:21:18;6813:2;6793:18;;;6786:30;-1:-1:-1;;;6832:18:18;;;6825:45;6887:18;;6512:30:17;6572:339:18;6512:30:17;6567:8;-1:-1:-1;;;;;6557:24:17;;6577:3;6557:24;;;;2324:25:18;;2312:2;2297:18;;2178:177;6557:24:17;;;;;;;;6404:184;;6375:213::o;4464:132:3:-;4550:39;4567:4;4573:2;4577:7;4550:39;;;;;;;;;;;;:16;:39::i;:::-;4464:132;;;:::o;5697:88:17:-;5741:7;5771:11;;5759:9;:23;;;;:::i;:::-;5752:30;;5697:88;:::o;6683:252::-;1531:13:0;:11;:13::i;:::-;6755:14:17::1;::::0;::::1;;6751:45;;;6778:18;;-1:-1:-1::0;;;6778:18:17::1;;;;;;;;;;;6751:45;6806:8;:12;6817:1:::0;;6806:8;:12:::1;:::i;:::-;;6833:17;6848:1;;6833:17;;;;;;;:::i;:::-;;;;;;;;6865:33;::::0;;6885:1:::1;9781:25:18::0;;6888:9:17::1;9837:2:18::0;9822:18;;9815:34;6865:33:17::1;::::0;9754:18:18;6865:33:17::1;;;;;;;6683:252:::0;;:::o;2103:118:3:-;2166:7;2192:22;2206:7;2192:13;:22::i;1861:208::-;1924:7;-1:-1:-1;;;;;1947:19:3;;1943:87;;1989:30;;-1:-1:-1;;;1989:30:3;;2016:1;1989:30;;;1679:51:18;1652:18;;1989:30:3;1533:203:18;1943:87:3;-1:-1:-1;;;;;;2046:16:3;;;;;:9;:16;;;;;;;1861:208::o;2293:101:0:-;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;2244:229:1:-;1311:13;;735:10:9;;-1:-1:-1;;;;;1311:13:1;2339:24;;2335:96;;2386:34;;-1:-1:-1;;;2386:34:1;;-1:-1:-1;;;;;1697:32:18;;2386:34:1;;;1679:51:18;1652:18;;2386:34:1;1533:203:18;2335:96:1;2440:26;2459:6;2440:18;:26::i;:::-;2286:187;2244:229::o;6122:160:17:-;1531:13:0;:11;:13::i;:::-;6188:8:17::1;6184:1;:12;6180:39;;;6205:14;;-1:-1:-1::0;;;6205:14:17::1;;;;;;;;;;;6180:39;6247:5;::::0;6234:22:::1;::::0;;9781:25:18;;;9837:2;9822:18;;9815:34;;;6234:22:17::1;::::0;9754:18:18;6234:22:17::1;;;;;;;6266:5;:9:::0;6122:160::o;2394:93:3:-;2441:13;2473:7;2466:14;;;;;:::i;4325:624:17:-;4383:8;;;:26;;;4401:8;4395:3;:14;4383:26;4379:47;;;4418:8;;-1:-1:-1;;;4418:8:17;;;;;;;;;;;4379:47;4448:11;;4483:9;4473:7;4477:3;4448:11;4473:7;:::i;:::-;:19;4469:41;;;4501:9;;-1:-1:-1;;;4501:9:17;;;;;;;;;;;4469:41;4544:10;4520:12;4535:20;;;:8;:20;;;;;;;4577:10;4584:3;4535:20;4577:10;:::i;:::-;4565:22;;4605:12;4601:1;:16;4597:40;;;4626:11;;-1:-1:-1;;;4626:11:17;;;;;;;;;;;4597:40;4664:16;4670:4;4676:3;4664:5;:16::i;:::-;4651:9;:29;4647:56;;4689:14;;-1:-1:-1;;;4689:14:17;;;;;;;;;;;4647:56;4722:10;4713:20;;;;:8;:20;;;;;:24;;;4761:7;4765:3;4761:1;:7;:::i;:::-;4747:11;:21;4795:1;4778:59;4803:3;4798:1;:8;4778:59;;4813:24;4819:10;4831:5;4835:1;4831;:5;:::i;:::-;4813;:24::i;:::-;4808:3;;;;:::i;:::-;;;;4778:59;;;-1:-1:-1;4908:10:17;4901:41;4920:5;:1;4924;4920:5;:::i;:::-;4901:41;;;10585:25:18;;;10641:2;10626:18;;10619:34;;;4932:9:17;10669:18:18;;;10662:34;10573:2;10558:18;4901:41:17;;;;;;;4369:580;;;4325:624;:::o;3487:144:3:-;3572:52;735:10:9;3605:8:3;3615;3572:18;:52::i;4630:233::-;4743:31;4756:4;4762:2;4766:7;4743:12;:31::i;:::-;4784:72;735:10:9;4832:4:3;4838:2;4842:7;4851:4;4784:33;:72::i;2529:255::-;2593:13;2618:22;2632:7;2618:13;:22::i;:::-;;2651:21;2675:10;:8;:10::i;:::-;2651:34;;2726:1;2708:7;2702:21;:25;:75;;;;;;;;;;;;;;;;;2744:7;2753:18;:7;:16;:18::i;:::-;2730:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2702:75;2695:82;2529:255;-1:-1:-1;;;2529:255:3:o;7003:177:17:-;1531:13:0;:11;:13::i;:::-;7062:14:17::1;::::0;::::1;;7058:45;;;7085:18;;-1:-1:-1::0;;;7085:18:17::1;;;;;;;;;;;7058:45;7113:14;:21:::0;;-1:-1:-1;;7113:21:17::1;7130:4;7113:21;::::0;;7149:24:::1;::::0;::::1;::::0;::::1;::::0;7164:8:::1;::::0;7149:24:::1;:::i;:::-;;;;;;;;7003:177::o:0;5919:85::-;5965:13;5989:12;5982:19;;;;;:::i;3665:153:3:-;-1:-1:-1;;;;;3776:25:3;;;3753:4;3776:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;3665:153::o;1649:178:1:-;1531:13:0;:11;:13::i;:::-;1738::1::1;:24:::0;;-1:-1:-1;;;;;1738:24:1;::::1;-1:-1:-1::0;;;;;;1738:24:1;;::::1;::::0;::::1;::::0;;;1802:7:::1;1710:6:0::0;;-1:-1:-1;;;;;1710:6:0;;1638:85;1802:7:1::1;-1:-1:-1::0;;;;;1777:43:1::1;;;;;;;;;;;1649:178:::0;:::o;5308:156:17:-;5374:7;5397:3;5404:1;5397:8;5393:22;;-1:-1:-1;5414:1:17;5407:8;;5393:22;-1:-1:-1;;;;;5438:13:17;;;;;;:8;:13;;;;;;5432:25;;5453:3;5432:5;:25::i;1527:300:3:-;1629:4;-1:-1:-1;;;;;;1664:40:3;;-1:-1:-1;;;1664:40:3;;:104;;-1:-1:-1;;;;;;;1720:48:3;;-1:-1:-1;;;1720:48:3;1664:104;:156;;;-1:-1:-1;;;;;;;;;;829:40:12;;;1784:36:3;730:146:12;15957:241:3;16020:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:3;;16082:88;;16128:31;;-1:-1:-1;;;16128:31:3;;;;;2324:25:18;;;2297:18;;16128:31:3;2178:177:18;14138:120:3;14218:33;14227:2;14231:7;14240:4;14246;14218:8;:33::i;8507:795::-;8593:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:3;;;;8704:18;;;8700:86;;8738:37;8755:4;8761;8767:7;8738:16;:37::i;:::-;-1:-1:-1;;;;;8830:18:3;;;8826:256;;8946:48;8963:1;8967:7;8984:1;8988:5;8946:8;:48::i;:::-;-1:-1:-1;;;;;9037:15:3;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9037:20:3;;;8826:256;-1:-1:-1;;;;;9096:16:3;;;9092:107;;-1:-1:-1;;;;;9156:13:3;;;;;;:9;:13;;;;;:18;;9173:1;9156:18;;;9092:107;9209:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9209:21:3;-1:-1:-1;;;;;9209:21:3;;;;;;;;;9246:27;;9209:16;;9246:27;;;;;;;9291:4;8507:795;-1:-1:-1;;;;8507:795:3:o;1796:162:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;735:10:9;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:9;1901:40:0;;;1679:51:18;1652:18;;1901:40:0;1533:203:18;2011:153:1;2100:13;2093:20;;-1:-1:-1;;;;;;2093:20:1;;;2123:34;2148:8;2123:24;:34::i;4955:166:17:-;5020:7;5055:9;;:25;;5077:3;5055:25;;;5067:7;5073:1;5067:3;:7;:::i;:::-;5046:5;;:35;;;;:::i;9624:327:3:-;-1:-1:-1;;;;;9691:16:3;;9687:87;;9730:33;;-1:-1:-1;;;9730:33:3;;9760:1;9730:33;;;1679:51:18;1652:18;;9730:33:3;1533:203:18;9687:87:3;9783:21;9807:32;9815:2;9819:7;9836:1;9807:7;:32::i;:::-;9783:56;-1:-1:-1;;;;;;9853:27:3;;;9849:96;;9903:31;;-1:-1:-1;;;9903:31:3;;9931:1;9903:31;;;1679:51:18;1652:18;;9903:31:3;1533:203:18;15311:411:3;-1:-1:-1;;;;;15418:19:3;;15414:90;;15460:33;;-1:-1:-1;;;15460:33:3;;15490:1;15460:33;;;1679:51:18;1652:18;;15460:33:3;1533:203:18;15414:90:3;-1:-1:-1;;;;;15517:22:3;;15513:91;;15562:31;;-1:-1:-1;;;15562:31:3;;-1:-1:-1;;;;;1697:32:18;;15562:31:3;;;1679:51:18;1652:18;;15562:31:3;1533:203:18;15513:91:3;-1:-1:-1;;;;;15613:25:3;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;15613:46:3;;;;;;;;;;15674:41;;540::18;;;15674::3;;513:18:18;15674:41:3;;;;;;;15311:411;;;:::o;994:926:7:-;-1:-1:-1;;;;;1174:14:7;;;:18;1170:744;;1212:67;;-1:-1:-1;;;1212:67:7;;-1:-1:-1;;;;;1212:36:7;;;;;:67;;1249:8;;1259:4;;1265:7;;1274:4;;1212:67;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1212:67:7;;;;;;;;-1:-1:-1;;1212:67:7;;;;;;;;;;;;:::i;:::-;;;1208:696;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1569:6;:13;1586:1;1569:18;1565:325;;1673:39;;-1:-1:-1;;;1673:39:7;;-1:-1:-1;;;;;1697:32:18;;1673:39:7;;;1679:51:18;1652:18;;1673:39:7;1533:203:18;1565:325:7;1842:6;1836:13;1829:4;1821:6;1817:17;1810:40;1208:696;-1:-1:-1;;;;;;1326:51:7;;-1:-1:-1;;;1326:51:7;1322:182;;1446:39;;-1:-1:-1;;;1446:39:7;;-1:-1:-1;;;;;1697:32:18;;1446:39:7;;;1679:51:18;1652:18;;1446:39:7;1533:203:18;1322:182:7;1280:238;1208:696;994:926;;;;;:::o;7395:87:17:-;7447:13;7471:8;7464:15;;;;;:::i;1251:634:11:-;1307:13;1356:14;1373:17;1384:5;1373:10;:17::i;:::-;1393:1;1373:21;1356:38;;1408:20;1442:6;1431:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1431:18:11;-1:-1:-1;1408:41:11;-1:-1:-1;1538:30:11;;;1554:4;1538:30;1595:247;-1:-1:-1;;1626:5:11;-1:-1:-1;;;1725:2:11;1714:14;;1709:32;1626:5;1696:46;1786:2;1777:11;;;-1:-1:-1;1806:21:11;1595:247;1806:21;-1:-1:-1;1862:6:11;1251:634;-1:-1:-1;;;1251:634:11:o;14440:662:3:-;14600:9;:31;;;-1:-1:-1;;;;;;14613:18:3;;;;14600:31;14596:460;;;14647:13;14663:22;14677:7;14663:13;:22::i;:::-;14647:38;-1:-1:-1;;;;;;14813:18:3;;;;;;:35;;;14844:4;-1:-1:-1;;;;;14835:13:3;:5;-1:-1:-1;;;;;14835:13:3;;;14813:35;:69;;;;;14853:29;14870:5;14877:4;14853:16;:29::i;:::-;14852:30;14813:69;14809:142;;;14909:27;;-1:-1:-1;;;14909:27:3;;-1:-1:-1;;;;;1697:32:18;;14909:27:3;;;1679:51:18;1652:18;;14909:27:3;1533:203:18;14809:142:3;14969:9;14965:81;;;15023:7;15019:2;-1:-1:-1;;;;;15003:28:3;15012:5;-1:-1:-1;;;;;15003:28:3;;;;;;;;;;;14965:81;14633:423;14596:460;-1:-1:-1;;15066:24:3;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15066:29:3;-1:-1:-1;;;;;15066:29:3;;;;;;;;;;14440:662::o;6751:368::-;6863:38;6877:5;6884:7;6893;6863:13;:38::i;:::-;6858:255;;-1:-1:-1;;;;;6921:19:3;;6917:186;;6967:31;;-1:-1:-1;;;6967:31:3;;;;;2324:25:18;;;2297:18;;6967:31:3;2178:177:18;6917:186:3;7044:44;;-1:-1:-1;;;7044:44:3;;-1:-1:-1;;;;;13420:32:18;;7044:44:3;;;13402:51:18;13469:18;;;13462:34;;;13375:18;;7044:44:3;13228:274:18;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;29471:916:14:-;29524:7;;-1:-1:-1;;;29599:17:14;;29595:103;;-1:-1:-1;;;29636:17:14;;;-1:-1:-1;29681:2:14;29671:12;29595:103;29724:8;29715:5;:17;29711:103;;29761:8;29752:17;;;-1:-1:-1;29797:2:14;29787:12;29711:103;29840:8;29831:5;:17;29827:103;;29877:8;29868:17;;;-1:-1:-1;29913:2:14;29903:12;29827:103;29956:7;29947:5;:16;29943:100;;29992:7;29983:16;;;-1:-1:-1;30027:1:14;30017:11;29943:100;30069:7;30060:5;:16;30056:100;;30105:7;30096:16;;;-1:-1:-1;30140:1:14;30130:11;30056:100;30182:7;30173:5;:16;30169:100;;30218:7;30209:16;;;-1:-1:-1;30253:1:14;30243:11;30169:100;30295:7;30286:5;:16;30282:66;;30332:1;30322:11;30374:6;29471:916;-1:-1:-1;;29471:916:14:o;6047:272:3:-;6150:4;-1:-1:-1;;;;;6185:21:3;;;;;;:127;;;6232:7;-1:-1:-1;;;;;6223:16:3;:5;-1:-1:-1;;;;;6223:16:3;;:52;;;;6243:32;6260:5;6267:7;6243:16;:32::i;:::-;6223:88;;;-1:-1:-1;5679:7:3;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6279:32:3;;;5705:24;;6279:32;6223:88;6166:146;6047:272;-1:-1:-1;;;;6047:272:3:o;14:131:18:-;-1:-1:-1;;;;;;88:32:18;;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:18;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:18;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:18: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:18;;1348:180;-1:-1:-1;1348:180:18:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:18;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:18:o;2360:328::-;2437:6;2445;2453;2506:2;2494:9;2485:7;2481:23;2477:32;2474:52;;;2522:1;2519;2512:12;2474:52;2545:29;2564:9;2545:29;:::i;:::-;2535:39;;2593:38;2627:2;2616:9;2612:18;2593:38;:::i;:::-;2583:48;;2678:2;2667:9;2663:18;2650:32;2640:42;;2360:328;;;;;:::o;2693:186::-;2752:6;2805:2;2793:9;2784:7;2780:23;2776:32;2773:52;;;2821:1;2818;2811:12;2773:52;2844:29;2863:9;2844:29;:::i;2884:592::-;2955:6;2963;3016:2;3004:9;2995:7;2991:23;2987:32;2984:52;;;3032:1;3029;3022:12;2984:52;3072:9;3059:23;3101:18;3142:2;3134:6;3131:14;3128:34;;;3158:1;3155;3148:12;3128:34;3196:6;3185:9;3181:22;3171:32;;3241:7;3234:4;3230:2;3226:13;3222:27;3212:55;;3263:1;3260;3253:12;3212:55;3303:2;3290:16;3329:2;3321:6;3318:14;3315:34;;;3345:1;3342;3335:12;3315:34;3390:7;3385:2;3376:6;3372:2;3368:15;3364:24;3361:37;3358:57;;;3411:1;3408;3401:12;3358:57;3442:2;3434:11;;;;;3464:6;;-1:-1:-1;2884:592:18;;-1:-1:-1;;;;2884:592:18:o;3705:347::-;3770:6;3778;3831:2;3819:9;3810:7;3806:23;3802:32;3799:52;;;3847:1;3844;3837:12;3799:52;3870:29;3889:9;3870:29;:::i;:::-;3860:39;;3949:2;3938:9;3934:18;3921:32;3996:5;3989:13;3982:21;3975:5;3972:32;3962:60;;4018:1;4015;4008:12;3962:60;4041:5;4031:15;;;3705:347;;;;;:::o;4057:127::-;4118:10;4113:3;4109:20;4106:1;4099:31;4149:4;4146:1;4139:15;4173:4;4170:1;4163:15;4189:1138;4284:6;4292;4300;4308;4361:3;4349:9;4340:7;4336:23;4332:33;4329:53;;;4378:1;4375;4368:12;4329:53;4401:29;4420:9;4401:29;:::i;:::-;4391:39;;4449:38;4483:2;4472:9;4468:18;4449:38;:::i;:::-;4439:48;;4534:2;4523:9;4519:18;4506:32;4496:42;;4589:2;4578:9;4574:18;4561:32;4612:18;4653:2;4645:6;4642:14;4639:34;;;4669:1;4666;4659:12;4639:34;4707:6;4696:9;4692:22;4682:32;;4752:7;4745:4;4741:2;4737:13;4733:27;4723:55;;4774:1;4771;4764:12;4723:55;4810:2;4797:16;4832:2;4828;4825:10;4822:36;;;4838:18;;:::i;:::-;4913:2;4907:9;4881:2;4967:13;;-1:-1:-1;;4963:22:18;;;4987:2;4959:31;4955:40;4943:53;;;5011:18;;;5031:22;;;5008:46;5005:72;;;5057:18;;:::i;:::-;5097:10;5093:2;5086:22;5132:2;5124:6;5117:18;5172:7;5167:2;5162;5158;5154:11;5150:20;5147:33;5144:53;;;5193:1;5190;5183:12;5144:53;5249:2;5244;5240;5236:11;5231:2;5223:6;5219:15;5206:46;5294:1;5289:2;5284;5276:6;5272:15;5268:24;5261:35;5315:6;5305:16;;;;;;;4189:1138;;;;;;;:::o;5332:260::-;5400:6;5408;5461:2;5449:9;5440:7;5436:23;5432:32;5429:52;;;5477:1;5474;5467:12;5429:52;5500:29;5519:9;5500:29;:::i;:::-;5490:39;;5548:38;5582:2;5571:9;5567:18;5548:38;:::i;:::-;5538:48;;5332:260;;;;;:::o;5597:380::-;5676:1;5672:12;;;;5719;;;5740:61;;5794:4;5786:6;5782:17;5772:27;;5740:61;5847:2;5839:6;5836:14;5816:18;5813:38;5810:161;;5893:10;5888:3;5884:20;5881:1;5874:31;5928:4;5925:1;5918:15;5956:4;5953:1;5946:15;5810:161;;5597:380;;;:::o;6916:127::-;6977:10;6972:3;6968:20;6965:1;6958:31;7008:4;7005:1;6998:15;7032:4;7029:1;7022:15;7048:128;7115:9;;;7136:11;;;7133:37;;;7150:18;;:::i;7307:518::-;7409:2;7404:3;7401:11;7398:421;;;7445:5;7442:1;7435:16;7489:4;7486:1;7476:18;7559:2;7547:10;7543:19;7540:1;7536:27;7530:4;7526:38;7595:4;7583:10;7580:20;7577:47;;;-1:-1:-1;7618:4:18;7577:47;7673:2;7668:3;7664:12;7661:1;7657:20;7651:4;7647:31;7637:41;;7728:81;7746:2;7739:5;7736:13;7728:81;;;7805:1;7791:16;;7772:1;7761:13;7728:81;;8001:1198;8125:18;8120:3;8117:27;8114:53;;;8147:18;;:::i;:::-;8176:94;8266:3;8226:38;8258:4;8252:11;8226:38;:::i;:::-;8220:4;8176:94;:::i;:::-;8296:1;8321:2;8316:3;8313:11;8338:1;8333:608;;;;8985:1;9002:3;8999:93;;;-1:-1:-1;9058:19:18;;;9045:33;8999:93;-1:-1:-1;;7958:1:18;7954:11;;;7950:24;7946:29;7936:40;7982:1;7978:11;;;7933:57;9105:78;;8306:887;;8333:608;7254:1;7247:14;;;7291:4;7278:18;;-1:-1:-1;;8369:17:18;;;8484:229;8498:7;8495:1;8492:14;8484:229;;;8587:19;;;8574:33;8559:49;;8694:4;8679:20;;;;8647:1;8635:14;;;;8514:12;8484:229;;;8488:3;8741;8732:7;8729:16;8726:159;;;8865:1;8861:6;8855:3;8849;8846:1;8842:11;8838:21;8834:34;8830:39;8817:9;8812:3;8808:19;8795:33;8791:79;8783:6;8776:95;8726:159;;;8928:1;8922:3;8919:1;8915:11;8911:19;8905:4;8898:33;8306:887;;8001:1198;;;:::o;9204:390::-;9363:2;9352:9;9345:21;9402:6;9397:2;9386:9;9382:18;9375:34;9459:6;9451;9446:2;9435:9;9431:18;9418:48;9515:1;9486:22;;;9510:2;9482:31;;;9475:42;;;;9578:2;9557:15;;;-1:-1:-1;;9553:29:18;9538:45;9534:54;;9204:390;-1:-1:-1;9204:390:18:o;10113:125::-;10178:9;;;10199:10;;;10196:36;;;10212:18;;:::i;10243:135::-;10282:3;10303:17;;;10300:43;;10323:18;;:::i;:::-;-1:-1:-1;10370:1:18;10359:13;;10243:135::o;10707:496::-;10886:3;10924:6;10918:13;10940:66;10999:6;10994:3;10987:4;10979:6;10975:17;10940:66;:::i;:::-;11069:13;;11028:16;;;;11091:70;11069:13;11028:16;11138:4;11126:17;;11091:70;:::i;:::-;11177:20;;10707:496;-1:-1:-1;;;;10707:496:18:o;11208:962::-;11317:4;11346:2;11375;11364:9;11357:21;11398:1;11431:6;11425:13;11461:36;11487:9;11461:36;:::i;:::-;11533:6;11528:2;11517:9;11513:18;11506:34;11559:2;11580:1;11612;11601:9;11597:17;11628:1;11623:158;;;;11795:1;11790:354;;;;11590:554;;11623:158;11690:3;11686:8;11675:9;11671:24;11666:2;11655:9;11651:18;11644:52;11768:2;11756:6;11749:14;11742:22;11739:1;11735:30;11724:9;11720:46;11716:55;11709:62;;11623:158;;11790:354;11821:6;11818:1;11811:17;11869:2;11866:1;11856:16;11894:1;11908:180;11922:6;11919:1;11916:13;11908:180;;;12015:14;;11991:17;;;11987:26;;11980:50;12058:16;;;;11937:10;;11908:180;;;12112:17;;12131:2;12108:26;;-1:-1:-1;;11590:554:18;-1:-1:-1;12161:3:18;;11208:962;-1:-1:-1;;;;;;;;11208:962:18:o;12175:168::-;12248:9;;;12279;;12296:15;;;12290:22;;12276:37;12266:71;;12317:18;;:::i;12348:489::-;-1:-1:-1;;;;;12617:15:18;;;12599:34;;12669:15;;12664:2;12649:18;;12642:43;12716:2;12701:18;;12694:34;;;12764:3;12759:2;12744:18;;12737:31;;;12542:4;;12785:46;;12811:19;;12803:6;12785:46;:::i;:::-;12777:54;12348:489;-1:-1:-1;;;;;;12348:489:18:o;12842:249::-;12911:6;12964:2;12952:9;12943:7;12939:23;12935:32;12932:52;;;12980:1;12977;12970:12;12932:52;13012:9;13006:16;13031:30;13055:5;13031:30;:::i","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220147e78fa91f21765b0e050c8d20867827c0cd07f6a53ccb37271e9d4e2348ae664736f6c63430008180033","offset":7468}},"immutableReferences":{"7592":[{"start":1423,"length":32},{"start":2478,"length":32},{"start":2649,"length":32},{"start":3130,"length":32}],"7595":[{"start":884,"length":32},{"start":3232,"length":32}],"7598":[{"start":1720,"length":32},{"start":3061,"length":32}],"7601":[{"start":1352,"length":32}],"7604":[{"start":1556,"length":32},{"start":2908,"length":32}],"7607":[{"start":986,"length":32},{"start":2177,"length":32},{"start":2340,"length":32}]},"transformations":[{"id":"7595","type":"replace","offset":884,"reason":"immutable"},{"id":"7607","type":"replace","offset":986,"reason":"immutable"},{"id":"7601","type":"replace","offset":1352,"reason":"immutable"},{"id":"7592","type":"replace","offset":1423,"reason":"immutable"},{"id":"7604","type":"replace","offset":1556,"reason":"immutable"},{"id":"7598","type":"replace","offset":1720,"reason":"immutable"},{"id":"7607","type":"replace","offset":2177,"reason":"immutable"},{"id":"7607","type":"replace","offset":2340,"reason":"immutable"},{"id":"7592","type":"replace","offset":2478,"reason":"immutable"},{"id":"7592","type":"replace","offset":2649,"reason":"immutable"},{"id":"7604","type":"replace","offset":2908,"reason":"immutable"},{"id":"7598","type":"replace","offset":3061,"reason":"immutable"},{"id":"7592","type":"replace","offset":3130,"reason":"immutable"},{"id":"7595","type":"replace","offset":3232,"reason":"immutable"}],"transformationValues":{"immutables":{"7592":"0x00000000000000000000000000000000000000000000000000000000000015b3","7595":"0x000000000000000000000000000000000000000000000000000000000000000a","7598":"0x000000000000000000000000000000000000000000000000000000000000000a","7601":"0x0000000000000000000000000000000000000000000000000000000000000000","7604":"0x00000000000000000000000000000000000000000000000000071afd498d0000","7607":"0x000000000000000000000000f38131a439d885b274731bbed2688b03cdcad132"}}},"deployment":{"transactionHash":"0x56bbf6b4d8cd277b2a8597de85e11356ee468e871520e106bbef41ec588b86ef","blockNumber":"130261917","transactionIndex":"105","deployer":"0xF38131a439d885b274731bBED2688B03cdCAD132"},"sources":{"@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/access/Ownable2Step.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.20;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * This extension of the {Ownable} contract includes a two-step mechanism to transfer\n * ownership, where the new owner must call {acceptOwnership} in order to replace the\n * old one. This can help prevent common mistakes, such as transfers of ownership to\n * incorrect accounts, or to contracts that are unable to interact with the\n * permission system.\n *\n * The initial owner is specified at deployment time in the constructor for `Ownable`. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n    address private _pendingOwner;\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        return _pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     *\n     * Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        _pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        delete _pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        if (pendingOwner() != sender) {\n            revert OwnableUnauthorizedAccount(sender);\n        }\n        _transferOwnership(sender);\n    }\n}\n"},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)\n\npragma solidity >=0.8.4;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.24;\n\nimport {IERC721} from \"./IERC721.sol\";\nimport {IERC721Metadata} from \"./extensions/IERC721Metadata.sol\";\nimport {ERC721Utils} from \"./utils/ERC721Utils.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {Strings} from \"../../utils/Strings.sol\";\nimport {IERC165, ERC165} from \"../../utils/introspection/ERC165.sol\";\nimport {IERC721Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\nabstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {\n    using Strings for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    mapping(uint256 tokenId => address) private _owners;\n\n    mapping(address owner => uint256) private _balances;\n\n    mapping(uint256 tokenId => address) private _tokenApprovals;\n\n    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return\n            interfaceId == type(IERC721).interfaceId ||\n            interfaceId == type(IERC721Metadata).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /// @inheritdoc IERC721\n    function balanceOf(address owner) public view virtual returns (uint256) {\n        if (owner == address(0)) {\n            revert ERC721InvalidOwner(address(0));\n        }\n        return _balances[owner];\n    }\n\n    /// @inheritdoc IERC721\n    function ownerOf(uint256 tokenId) public view virtual returns (address) {\n        return _requireOwned(tokenId);\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {\n        _requireOwned(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /// @inheritdoc IERC721\n    function approve(address to, uint256 tokenId) public virtual {\n        _approve(to, tokenId, _msgSender());\n    }\n\n    /// @inheritdoc IERC721\n    function getApproved(uint256 tokenId) public view virtual returns (address) {\n        _requireOwned(tokenId);\n\n        return _getApproved(tokenId);\n    }\n\n    /// @inheritdoc IERC721\n    function setApprovalForAll(address operator, bool approved) public virtual {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /// @inheritdoc IERC721\n    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /// @inheritdoc IERC721\n    function transferFrom(address from, address to, uint256 tokenId) public virtual {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        // Setting an \"auth\" arguments enables the `_isAuthorized` check which verifies that the token exists\n        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.\n        address previousOwner = _update(to, tokenId, _msgSender());\n        if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /// @inheritdoc IERC721\n    function safeTransferFrom(address from, address to, uint256 tokenId) public {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /// @inheritdoc IERC721\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {\n        transferFrom(from, to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     *\n     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the\n     * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances\n     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by\n     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.\n     */\n    function _getApproved(uint256 tokenId) internal view virtual returns (address) {\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in\n     * particular (ignoring whether it is owned by `owner`).\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {\n        return\n            spender != address(0) &&\n            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.\n     * Reverts if:\n     * - `spender` does not have approval from `owner` for `tokenId`.\n     * - `spender` does not have approval to manage all of `owner`'s assets.\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {\n        if (!_isAuthorized(owner, spender, tokenId)) {\n            if (owner == address(0)) {\n                revert ERC721NonexistentToken(tokenId);\n            } else {\n                revert ERC721InsufficientApproval(spender, tokenId);\n            }\n        }\n    }\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that\n     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.\n     *\n     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the\n     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership\n     * remain consistent with one another.\n     */\n    function _increaseBalance(address account, uint128 value) internal virtual {\n        unchecked {\n            _balances[account] += value;\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner\n     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that\n     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.\n     */\n    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {\n        address from = _ownerOf(tokenId);\n\n        // Perform (optional) operator check\n        if (auth != address(0)) {\n            _checkAuthorized(from, auth, tokenId);\n        }\n\n        // Execute the update\n        if (from != address(0)) {\n            // Clear approval. No need to re-authorize or emit the Approval event\n            _approve(address(0), tokenId, address(0), false);\n\n            unchecked {\n                _balances[from] -= 1;\n            }\n        }\n\n        if (to != address(0)) {\n            unchecked {\n                _balances[to] += 1;\n            }\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        return from;\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner != address(0)) {\n            revert ERC721InvalidSender(address(0));\n        }\n    }\n\n    /**\n     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal {\n        address previousOwner = _update(address(0), tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        } else if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients\n     * are aware of the ERC-721 standard to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is like {safeTransferFrom} in the sense that it invokes\n     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `tokenId` token must exist and be owned by `from`.\n     * - `to` cannot be the zero address.\n     * - `from` cannot be the zero address.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId) internal {\n        _safeTransfer(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is\n     * either the owner of the token, or approved to operate on all tokens held by this owner.\n     *\n     * Emits an {Approval} event.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address to, uint256 tokenId, address auth) internal {\n        _approve(to, tokenId, auth, true);\n    }\n\n    /**\n     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not\n     * emitted in the context of transfers.\n     */\n    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {\n        // Avoid reading the owner unless necessary\n        if (emitEvent || auth != address(0)) {\n            address owner = _requireOwned(tokenId);\n\n            // We do not use _isAuthorized because single-token approvals should not be able to call approve\n            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {\n                revert ERC721InvalidApprover(auth);\n            }\n\n            if (emitEvent) {\n                emit Approval(owner, to, tokenId);\n            }\n        }\n\n        _tokenApprovals[tokenId] = to;\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Requirements:\n     * - operator can't be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        if (owner == address(0)) {\n            revert ERC721InvalidApprover(address(0));\n        }\n        if (operator == address(0)) {\n            revert ERC721InvalidOperator(operator);\n        }\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).\n     * Returns the owner.\n     *\n     * Overrides to ownership logic should be done to {_ownerOf}.\n     */\n    function _requireOwned(uint256 tokenId) internal view returns (address) {\n        address owner = _ownerOf(tokenId);\n        if (owner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n        return owner;\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC721} from \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC-721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n     *   {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @title ERC-721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC-721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC721/utils/ERC721Utils.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721Receiver} from \"../IERC721Receiver.sol\";\nimport {IERC721Errors} from \"../../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Library that provides common ERC-721 utility functions.\n *\n * See https://eips.ethereum.org/EIPS/eip-721[ERC-721].\n *\n * _Available since v5.1._\n */\nlibrary ERC721Utils {\n    /**\n     * @dev Performs an acceptance check for the provided `operator` by calling {IERC721Receiver-onERC721Received}\n     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).\n     *\n     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).\n     * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept\n     * the transfer.\n     */\n    function checkOnERC721Received(\n        address operator,\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes memory data\n    ) internal {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) {\n                if (retval != IERC721Receiver.onERC721Received.selector) {\n                    // Token rejected\n                    revert IERC721Errors.ERC721InvalidReceiver(to);\n                }\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    // non-IERC721Receiver implementer\n                    revert IERC721Errors.ERC721InvalidReceiver(to);\n                } else {\n                    assembly (\"memory-safe\") {\n                        revert(add(reason, 0x20), mload(reason))\n                    }\n                }\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Bytes.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/Bytes.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\n\n/**\n * @dev Bytes operations.\n */\nlibrary Bytes {\n    /**\n     * @dev Forward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the first instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return indexOf(buffer, s, 0);\n    }\n\n    /**\n     * @dev Forward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or after `pos`), returns the index of the next instance\n     * * If `s` is not present in the buffer (at or after `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        uint256 length = buffer.length;\n        for (uint256 i = pos; i < length; ++i) {\n            if (bytes1(_unsafeReadBytesOffset(buffer, i)) == s) {\n                return i;\n            }\n        }\n        return type(uint256).max;\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the last instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return lastIndexOf(buffer, s, type(uint256).max);\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or before `pos`), returns the index of the previous instance\n     * * If `s` is not present in the buffer (at or before `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        unchecked {\n            uint256 length = buffer.length;\n            for (uint256 i = Math.min(Math.saturatingAdd(pos, 1), length); i > 0; --i) {\n                if (bytes1(_unsafeReadBytesOffset(buffer, i - 1)) == s) {\n                    return i - 1;\n                }\n            }\n            return type(uint256).max;\n        }\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to the end of `buffer` into a new bytes object in\n     * memory.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return slice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to `end` (excluded) into a new bytes object in\n     * memory. The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // allocate and copy\n        bytes memory result = new bytes(end - start);\n        assembly (\"memory-safe\") {\n            mcopy(add(result, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to the end of `buffer` to the start of that buffer,\n     * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:].\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     */\n    function splice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return splice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to `end` (excluded) to the start of that buffer,\n     * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:end].\n     * The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     */\n    function splice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // move and resize\n        assembly (\"memory-safe\") {\n            mcopy(add(buffer, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n            mstore(buffer, sub(end, start))\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Replaces bytes in `buffer` starting at `pos` with all bytes from `replacement`.\n     *\n     * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`).\n     * If `pos >= buffer.length`, no replacement occurs and the buffer is returned unchanged.\n     *\n     * NOTE: This function modifies the provided buffer in place.\n     */\n    function replace(bytes memory buffer, uint256 pos, bytes memory replacement) internal pure returns (bytes memory) {\n        return replace(buffer, pos, replacement, 0, replacement.length);\n    }\n\n    /**\n     * @dev Replaces bytes in `buffer` starting at `pos` with bytes from `replacement` starting at `offset`.\n     * Copies at most `length` bytes from `replacement` to `buffer`.\n     *\n     * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`, `offset` is\n     * clamped to `[0, replacement.length]`, and `length` is clamped to `min(length, replacement.length - offset,\n     * buffer.length - pos))`. If `pos >= buffer.length` or `offset >= replacement.length`, no replacement occurs\n     * and the buffer is returned unchanged.\n     *\n     * NOTE: This function modifies the provided buffer in place.\n     */\n    function replace(\n        bytes memory buffer,\n        uint256 pos,\n        bytes memory replacement,\n        uint256 offset,\n        uint256 length\n    ) internal pure returns (bytes memory) {\n        // sanitize\n        pos = Math.min(pos, buffer.length);\n        offset = Math.min(offset, replacement.length);\n        length = Math.min(length, Math.min(replacement.length - offset, buffer.length - pos));\n\n        // replace\n        assembly (\"memory-safe\") {\n            mcopy(add(add(buffer, 0x20), pos), add(add(replacement, 0x20), offset), length)\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Concatenate an array of bytes into a single bytes object.\n     *\n     * For fixed bytes types, we recommend using the solidity built-in `bytes.concat` or (equivalent)\n     * `abi.encodePacked`.\n     *\n     * NOTE: this could be done in assembly with a single loop that expands starting at the FMP, but that would be\n     * significantly less readable. It might be worth benchmarking the savings of the full-assembly approach.\n     */\n    function concat(bytes[] memory buffers) internal pure returns (bytes memory) {\n        uint256 length = 0;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            length += buffers[i].length;\n        }\n\n        bytes memory result = new bytes(length);\n\n        uint256 offset = 0x20;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            bytes memory input = buffers[i];\n            assembly (\"memory-safe\") {\n                mcopy(add(result, offset), add(input, 0x20), mload(input))\n            }\n            unchecked {\n                offset += input.length;\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Split each byte in `input` into two nibbles (4 bits each)\n     *\n     * Example: hex\"01234567\" → hex\"0001020304050607\"\n     */\n    function toNibbles(bytes memory input) internal pure returns (bytes memory output) {\n        assembly (\"memory-safe\") {\n            let length := mload(input)\n            output := mload(0x40)\n            mstore(0x40, add(add(output, 0x20), mul(length, 2)))\n            mstore(output, mul(length, 2))\n            for {\n                let i := 0\n            } lt(i, length) {\n                i := add(i, 0x10)\n            } {\n                let chunk := shr(128, mload(add(add(input, 0x20), i)))\n                chunk := and(\n                    0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff,\n                    or(shl(64, chunk), chunk)\n                )\n                chunk := and(\n                    0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff,\n                    or(shl(32, chunk), chunk)\n                )\n                chunk := and(\n                    0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff,\n                    or(shl(16, chunk), chunk)\n                )\n                chunk := and(\n                    0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff,\n                    or(shl(8, chunk), chunk)\n                )\n                chunk := and(\n                    0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f,\n                    or(shl(4, chunk), chunk)\n                )\n                mstore(add(add(output, 0x20), mul(i, 2)), chunk)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns true if the two byte buffers are equal.\n     */\n    function equal(bytes memory a, bytes memory b) internal pure returns (bool) {\n        return a.length == b.length && keccak256(a) == keccak256(b);\n    }\n\n    /**\n     * @dev Reverses the byte order of a bytes32 value, converting between little-endian and big-endian.\n     * Inspired by https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel[Reverse Parallel]\n     */\n    function reverseBytes32(bytes32 value) internal pure returns (bytes32) {\n        value = // swap bytes\n            ((value >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        value = // swap 8-byte long pairs\n            ((value >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |\n            ((value & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);\n        return (value >> 128) | (value << 128); // swap 16-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 128-bit values.\n    function reverseBytes16(bytes16 value) internal pure returns (bytes16) {\n        value = // swap bytes\n            ((value & 0xFF00FF00FF00FF00FF00FF00FF00FF00) >> 8) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value & 0xFFFF0000FFFF0000FFFF0000FFFF0000) >> 16) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value & 0xFFFFFFFF00000000FFFFFFFF00000000) >> 32) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        return (value >> 64) | (value << 64); // swap 8-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 64-bit values.\n    function reverseBytes8(bytes8 value) internal pure returns (bytes8) {\n        value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8); // swap bytes\n        value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16); // swap 2-byte long pairs\n        return (value >> 32) | (value << 32); // swap 4-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 32-bit values.\n    function reverseBytes4(bytes4 value) internal pure returns (bytes4) {\n        value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); // swap bytes\n        return (value >> 16) | (value << 16); // swap 2-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 16-bit values.\n    function reverseBytes2(bytes2 value) internal pure returns (bytes2) {\n        return (value >> 8) | (value << 8);\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits a bytes array. Returns `8 * buffer.length`\n     * if the buffer is all zeros.\n     */\n    function clz(bytes memory buffer) internal pure returns (uint256) {\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            bytes32 chunk = _unsafeReadBytesOffset(buffer, i);\n            if (chunk != bytes32(0)) {\n                return Math.min(8 * i + Math.clz(uint256(chunk)), 8 * buffer.length);\n            }\n        }\n        return 8 * buffer.length;\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Return the 512-bit addition of two uint256.\n     *\n     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.\n     */\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        assembly (\"memory-safe\") {\n            low := add(a, b)\n            high := lt(low, a)\n        }\n    }\n\n    /**\n     * @dev Return the 512-bit multiplication of two uint256.\n     *\n     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.\n     */\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n        // variables such that product = high * 2²⁵⁶ + low.\n        assembly (\"memory-safe\") {\n            let mm := mulmod(a, b, not(0))\n            low := mul(a, b)\n            high := sub(sub(mm, low), lt(mm, low))\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            success = c >= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a - b;\n            success = c <= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a * b;\n            assembly (\"memory-safe\") {\n                // Only true when the multiplication doesn't overflow\n                // (c / a == b) || (a == 0)\n                success := or(eq(div(c, a), b), iszero(a))\n            }\n            // equivalent to: success ? c : 0\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `DIV` opcode returns zero when the denominator is 0.\n                result := div(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `MOD` opcode returns zero when the denominator is 0.\n                result := mod(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryAdd(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\n     */\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\n        (, uint256 result) = trySub(a, b);\n        return result;\n    }\n\n    /**\n     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryMul(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // (a + b) / 2 can overflow.\n            return (a & b) + (a ^ b) / 2;\n        }\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (high == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return low / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= high) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [high low].\n            uint256 remainder;\n            assembly (\"memory-safe\") {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                high := sub(high, gt(remainder, low))\n                low := sub(low, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly (\"memory-safe\") {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [high low] by twos.\n                low := div(low, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from high into low.\n            low |= high * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high\n            // is no longer required.\n            result = low * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n            if (high >= 1 << n) {\n                Panic.panic(Panic.UNDER_OVERFLOW);\n            }\n            return (high << (256 - n)) | (low >> n);\n        }\n    }\n\n    /**\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory buffer) private pure returns (bool) {\n        uint256 chunk;\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            // See _unsafeReadBytesOffset from utils/Bytes.sol\n            assembly (\"memory-safe\") {\n                chunk := mload(add(add(buffer, 0x20), i))\n            }\n            if (chunk >> (8 * saturatingSub(i + 0x20, buffer.length)) != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // If upper 8 bits of 16-bit half set, add 8 to result\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\n        // If upper 4 bits of 8-bit half set, add 4 to result\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\n\n        // Shifts value right by the current result and use it as an index into this lookup table:\n        //\n        // | x (4 bits) |  index  | table[index] = MSB position |\n        // |------------|---------|-----------------------------|\n        // |    0000    |    0    |        table[0] = 0         |\n        // |    0001    |    1    |        table[1] = 0         |\n        // |    0010    |    2    |        table[2] = 1         |\n        // |    0011    |    3    |        table[3] = 1         |\n        // |    0100    |    4    |        table[4] = 2         |\n        // |    0101    |    5    |        table[5] = 2         |\n        // |    0110    |    6    |        table[6] = 2         |\n        // |    0111    |    7    |        table[7] = 2         |\n        // |    1000    |    8    |        table[8] = 3         |\n        // |    1001    |    9    |        table[9] = 3         |\n        // |    1010    |   10    |        table[10] = 3        |\n        // |    1011    |   11    |        table[11] = 3        |\n        // |    1100    |   12    |        table[12] = 3        |\n        // |    1101    |   13    |        table[13] = 3        |\n        // |    1110    |   14    |        table[14] = 3        |\n        // |    1111    |   15    |        table[15] = 3        |\n        //\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the first 16 bytes (most significant half).\n        assembly (\"memory-safe\") {\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits in a uint256.\n     */\n    function clz(uint256 x) internal pure returns (uint256) {\n        return ternary(x == 0, 256, 255 - log2(x));\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in a uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in a uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev A uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        assembly (\"memory-safe\") {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n *\n * _Available since v5.1._\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/Strings.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SafeCast} from \"./math/SafeCast.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\nimport {Bytes} from \"./Bytes.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    using SafeCast for *;\n\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n    uint256 private constant SPECIAL_CHARS_LOOKUP =\n        0xffffffff | // first 32 bits corresponding to the control characters (U+0000 to U+001F)\n            (1 << 0x22) | // double quote\n            (1 << 0x5c); // backslash\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev The string being parsed contains characters that are not in scope of the given base.\n     */\n    error StringsInvalidChar();\n\n    /**\n     * @dev The string being parsed is not a properly formatted address.\n     */\n    error StringsInvalidAddressFormat();\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            assembly (\"memory-safe\") {\n                ptr := add(add(buffer, 0x20), length)\n            }\n            while (true) {\n                ptr--;\n                assembly (\"memory-safe\") {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `bytes` buffer to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(bytes memory input) internal pure returns (string memory) {\n        unchecked {\n            bytes memory buffer = new bytes(2 * input.length + 2);\n            buffer[0] = \"0\";\n            buffer[1] = \"x\";\n            for (uint256 i = 0; i < input.length; ++i) {\n                uint8 v = uint8(input[i]);\n                buffer[2 * i + 2] = HEX_DIGITS[v >> 4];\n                buffer[2 * i + 3] = HEX_DIGITS[v & 0xf];\n            }\n            return string(buffer);\n        }\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return Bytes.equal(bytes(a), bytes(b));\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input) internal pure returns (uint256) {\n        return parseUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        uint256 result = 0;\n        for (uint256 i = begin; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 9) return (false, 0);\n            result *= 10;\n            result += chr;\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `int256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input) internal pure returns (int256) {\n        return parseInt(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {\n        (bool success, int256 value) = tryParseInt(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if\n     * the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {\n        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    uint256 private constant ABS_MIN_INT256 = 2 ** 255;\n\n    /**\n     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character or if the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, int256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseIntUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseIntUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, int256 value) {\n        bytes memory buffer = bytes(input);\n\n        // Check presence of a negative sign.\n        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        bool positiveSign = sign == bytes1(\"+\");\n        bool negativeSign = sign == bytes1(\"-\");\n        uint256 offset = (positiveSign || negativeSign).toUint();\n\n        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);\n\n        if (absSuccess && absValue < ABS_MIN_INT256) {\n            return (true, negativeSign ? -int256(absValue) : int256(absValue));\n        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {\n            return (true, type(int256).min);\n        } else return (false, 0);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input) internal pure returns (uint256) {\n        return parseHexUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseHexUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an\n     * invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseHexUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseHexUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        // skip 0x prefix if present\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 offset = hasPrefix.toUint() * 2;\n\n        uint256 result = 0;\n        for (uint256 i = begin + offset; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 15) return (false, 0);\n            result *= 16;\n            unchecked {\n                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).\n                // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.\n                result += chr;\n            }\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as an `address`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input) internal pure returns (address) {\n        return parseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {\n        (bool success, address value) = tryParseAddress(input, begin, end);\n        if (!success) revert StringsInvalidAddressFormat();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly\n     * formatted address. See {parseAddress-string} requirements.\n     */\n    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {\n        return tryParseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly\n     * formatted address. See {parseAddress-string-uint256-uint256} requirements.\n     */\n    function tryParseAddress(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, address value) {\n        if (end > bytes(input).length || begin > end) return (false, address(0));\n\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;\n\n        // check that input is the correct length\n        if (end - begin == expectedLength) {\n            // length guarantees that this does not overflow, and value is at most type(uint160).max\n            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);\n            return (s, address(uint160(v)));\n        } else {\n            return (false, address(0));\n        }\n    }\n\n    function _tryParseChr(bytes1 chr) private pure returns (uint8) {\n        uint8 value = uint8(chr);\n\n        // Try to parse `chr`:\n        // - Case 1: [0-9]\n        // - Case 2: [a-f]\n        // - Case 3: [A-F]\n        // - otherwise not supported\n        unchecked {\n            if (value > 47 && value < 58) value -= 48;\n            else if (value > 96 && value < 103) value -= 87;\n            else if (value > 64 && value < 71) value -= 55;\n            else return type(uint8).max;\n        }\n\n        return value;\n    }\n\n    /**\n     * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.\n     *\n     * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.\n     *\n     * NOTE: This function escapes backslashes (including those in \\uXXXX sequences) and the characters in ranges\n     * defined in section 2.5 of RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). All control characters in U+0000\n     * to U+001F are escaped (\\b, \\t, \\n, \\f, \\r use short form; others use \\u00XX). ECMAScript's `JSON.parse` does\n     * recover escaped unicode characters that are not in this range, but other tooling may provide different results.\n     */\n    function escapeJSON(string memory input) internal pure returns (string memory) {\n        bytes memory buffer = bytes(input);\n\n        // Put output at the FMP. Memory will be reserved later when we figure out the actual length of the escaped\n        // string. All write are done using _unsafeWriteBytesOffset, which avoid the (expensive) length checks for\n        // each character written.\n        bytes memory output;\n        assembly (\"memory-safe\") {\n            output := mload(0x40)\n        }\n        uint256 outputLength = 0;\n\n        for (uint256 i = 0; i < buffer.length; ++i) {\n            uint8 char = uint8(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (((SPECIAL_CHARS_LOOKUP & (1 << char)) != 0)) {\n                _unsafeWriteBytesOffset(output, outputLength++, \"\\\\\");\n                if (char == 0x08) _unsafeWriteBytesOffset(output, outputLength++, \"b\");\n                else if (char == 0x09) _unsafeWriteBytesOffset(output, outputLength++, \"t\");\n                else if (char == 0x0a) _unsafeWriteBytesOffset(output, outputLength++, \"n\");\n                else if (char == 0x0c) _unsafeWriteBytesOffset(output, outputLength++, \"f\");\n                else if (char == 0x0d) _unsafeWriteBytesOffset(output, outputLength++, \"r\");\n                else if (char == 0x5c) _unsafeWriteBytesOffset(output, outputLength++, \"\\\\\");\n                else if (char == 0x22) {\n                    // solhint-disable-next-line quotes\n                    _unsafeWriteBytesOffset(output, outputLength++, '\"');\n                } else {\n                    // U+0000 to U+001F without short form: output \\u00XX\n                    _unsafeWriteBytesOffset(output, outputLength++, \"u\");\n                    _unsafeWriteBytesOffset(output, outputLength++, \"0\");\n                    _unsafeWriteBytesOffset(output, outputLength++, \"0\");\n                    _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char >> 4]);\n                    _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char & 0x0f]);\n                }\n            } else {\n                _unsafeWriteBytesOffset(output, outputLength++, bytes1(char));\n            }\n        }\n        // write the actual length and reserve memory\n        assembly (\"memory-safe\") {\n            mstore(output, outputLength)\n            mstore(0x40, add(output, add(outputLength, 0x20)))\n        }\n\n        return string(output);\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n\n    /**\n     * @dev Write a bytes1 to a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeWriteBytesOffset(bytes memory buffer, uint256 offset, bytes1 value) private pure {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            mstore8(add(add(buffer, 0x20), offset), shr(248, value))\n        }\n    }\n}\n"},"contracts/CogitoAgentsV2.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {ERC721} from \"@openzeppelin/contracts/token/ERC721/ERC721.sol\";\nimport {Ownable2Step, Ownable} from \"@openzeppelin/contracts/access/Ownable2Step.sol\";\n\n/// @title Cogito Agents (COG-A) — AI-agent-first NFT on BNB Chain\n/// @author Cogito Agents — https://cogitoagents.pages.dev — X @CogitoAgents\n/// @notice HOW TO MINT (agents): 1) v = costFor(you, qty)  2) mint(qty) with msg.value == v exactly.\n///         Each wallet's FIRST NFT is free (gas only); every further NFT costs price() wei. Max maxPerWallet() per wallet.\n///         Machine-readable docs: https://cogitoagents.pages.dev/llms.txt and /mint.json\n/// @dev Owner powers are ONLY: setPrice (bounded by immutable maxPrice), setBaseURI (until freezeMetadata(), then never),\n///      freezeMetadata, and transfer/renounce ownership (Ownable2Step).\n///      No blacklist, no pause, no transfer restrictions, no owner mint (beyond an optional reserve fixed at deploy; default 0).\n///      No royalties (no ERC-2981). Proceeds accumulate in the contract; withdraw() is callable by anyone and pays ONLY the immutable treasury.\ncontract CogitoAgentsV2 is ERC721, Ownable2Step {\n    /// @notice Hard cap on total NFTs.\n    uint256 public immutable maxSupply;\n    /// @notice Max NFTs any single address can mint over its lifetime.\n    uint256 public immutable maxPerWallet;\n    /// @notice Max NFTs per mint() call.\n    uint256 public immutable maxPerTx;\n    /// @notice NFTs minted to the deployer at deploy (ids 1..reserve). Default deploy uses 0.\n    uint256 public immutable reserve;\n    /// @notice Ceiling for price(); setPrice can never exceed it.\n    uint256 public immutable maxPrice;\n    /// @notice The only address withdraw() can pay.\n    address payable public immutable treasury;\n\n    /// @notice Current price in wei for each NFT after a wallet's free first one.\n    uint256 public price;\n    /// @notice NFTs minted so far (token ids are 1..totalSupply).\n    uint256 public totalSupply;\n    /// @notice NFTs minted by each address (0 => its next NFT is free).\n    mapping(address => uint256) public mintedBy;\n    string private baseURI_;\n    /// @notice True once freezeMetadata() was called; baseURI can never change afterwards.\n    bool public metadataFrozen;\n    string private contractURI_;\n\n    /// @notice Emitted on every mint. paid == wei paid (0 for a free first mint).\n    event Minted(address indexed to, uint256 firstId, uint256 qty, uint256 paid);\n    event PriceChanged(uint256 oldPrice, uint256 newPrice);\n    event Withdrawn(address indexed to, uint256 amount);\n    /// @dev EIP-4906\n    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);\n    event BaseURIChanged(string newBaseURI);\n    event MetadataFrozen(string finalBaseURI);\n\n    error ZeroAddress();\n    error BadQty();\n    error SoldOut();\n    error WalletCap();\n    error WrongPayment();\n    error PriceTooHigh();\n    error BadConfig();\n    error MetadataIsFrozen();\n\n    constructor(\n        address payable treasury_, uint256 maxSupply_, uint256 maxPerWallet_, uint256 maxPerTx_,\n        uint256 reserve_, uint256 price_, uint256 maxPrice_, string memory base_, string memory contractURI__\n    ) ERC721(\"Cogito Agents\", \"COG-A\") Ownable(msg.sender) {\n        if (treasury_ == address(0)) revert ZeroAddress();\n        if (maxSupply_ == 0 || reserve_ > maxSupply_ || maxPerWallet_ == 0 || maxPerTx_ == 0 || price_ > maxPrice_) revert BadConfig();\n        treasury = treasury_; maxSupply = maxSupply_; maxPerWallet = maxPerWallet_; maxPerTx = maxPerTx_;\n        reserve = reserve_; price = price_; maxPrice = maxPrice_; baseURI_ = base_; contractURI_ = contractURI__;\n        for (uint256 i = 1; i <= reserve_; i++) _mint(msg.sender, i);\n        totalSupply = reserve_;\n        if (reserve_ > 0) emit Minted(msg.sender, 1, reserve_, 0);\n    }\n\n    /// @notice Mint `qty` NFTs to msg.sender.\n    /// @dev msg.value must EQUAL costFor(msg.sender, qty): price()*(qty-1) if the sender has never minted, else price()*qty.\n    ///      Reverts: BadQty (0 or > maxPerTx), SoldOut, WalletCap (> maxPerWallet total), WrongPayment (any other value).\n    ///      Free first mint example: mint(1) with value 0 — calldata 0xa0712d68 + uint256(1).\n    /// @param qty Number of NFTs (1..maxPerTx).\n    function mint(uint256 qty) external payable {\n        if (qty == 0 || qty > maxPerTx) revert BadQty();\n        uint256 s = totalSupply;\n        if (s + qty > maxSupply) revert SoldOut();\n        uint256 prev = mintedBy[msg.sender];\n        uint256 m = prev + qty;\n        if (m > maxPerWallet) revert WalletCap();\n        if (msg.value != _cost(prev, qty)) revert WrongPayment();\n        mintedBy[msg.sender] = m;\n        totalSupply = s + qty;\n        for (uint256 i = 1; i <= qty; i++) _mint(msg.sender, s + i); // _mint (not _safeMint): no callback reentrancy\n        emit Minted(msg.sender, s + 1, qty, msg.value);\n    }\n\n    function _cost(uint256 prev, uint256 qty) internal view returns (uint256) {\n        return price * (prev == 0 ? qty - 1 : qty); // first NFT of a wallet is free\n    }\n\n    /// @notice Exact wei `who` must send to mint `qty` right now (includes the free first NFT). Returns 0 for qty 0.\n    /// @param who Minting address. @param qty Number of NFTs.\n    function costFor(address who, uint256 qty) external view returns (uint256) {\n        if (qty == 0) return 0;\n        return _cost(mintedBy[who], qty);\n    }\n\n    /// @notice True if `who` has never minted, i.e. its next NFT is free.\n    function hasFreeMint(address who) external view returns (bool) { return mintedBy[who] == 0; }\n\n    /// @notice NFTs still mintable before sold out.\n    function remaining() external view returns (uint256) { return maxSupply - totalSupply; }\n\n    /// @notice Collection-level metadata (name, description, image, external_link) for marketplaces/indexers. Fixed at deploy.\n    function contractURI() external view returns (string memory) { return contractURI_; }\n\n    /// @notice Owner may adjust the price to track ~US$0.50 as BNB moves. Can never exceed immutable maxPrice.\n    function setPrice(uint256 p) external onlyOwner {\n        if (p > maxPrice) revert PriceTooHigh();\n        emit PriceChanged(price, p);\n        price = p;\n    }\n\n    /// @notice Anyone may call; the full balance goes only to the immutable treasury.\n    function withdraw() external {\n        uint256 bal = address(this).balance;\n        (bool ok, ) = treasury.call{value: bal}(\"\");\n        require(ok, \"transfer failed\");\n        emit Withdrawn(treasury, bal);\n    }\n\n    /// @notice Owner may change the metadata base URI until freezeMetadata() is called.\n    function setBaseURI(string calldata b) external onlyOwner {\n        if (metadataFrozen) revert MetadataIsFrozen();\n        baseURI_ = b;\n        emit BaseURIChanged(b);\n        emit BatchMetadataUpdate(1, maxSupply); // token ids are 1..maxSupply\n    }\n\n    /// @notice Permanently locks the base URI. Irreversible.\n    function freezeMetadata() external onlyOwner {\n        if (metadataFrozen) revert MetadataIsFrozen();\n        metadataFrozen = true;\n        emit MetadataFrozen(baseURI_);\n    }\n\n    /// @dev ERC-165 incl. EIP-4906 (0x49064906).\n    function supportsInterface(bytes4 id) public view override returns (bool) {\n        return id == bytes4(0x49064906) || super.supportsInterface(id);\n    }\n\n    function _baseURI() internal view override returns (string memory) { return baseURI_; }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.24+commit.e11b9ed9","compilerSettings":{"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun"},"name":"CogitoAgentsV2","fullyQualifiedName":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},"abi":[{"type":"constructor","inputs":[{"name":"treasury_","type":"address","internalType":"address payable"},{"name":"maxSupply_","type":"uint256","internalType":"uint256"},{"name":"maxPerWallet_","type":"uint256","internalType":"uint256"},{"name":"maxPerTx_","type":"uint256","internalType":"uint256"},{"name":"reserve_","type":"uint256","internalType":"uint256"},{"name":"price_","type":"uint256","internalType":"uint256"},{"name":"maxPrice_","type":"uint256","internalType":"uint256"},{"name":"base_","type":"string","internalType":"string"},{"name":"contractURI__","type":"string","internalType":"string"}],"stateMutability":"nonpayable"},{"name":"BadConfig","type":"error","inputs":[]},{"name":"BadQty","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":"MetadataIsFrozen","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":"PriceTooHigh","type":"error","inputs":[]},{"name":"SoldOut","type":"error","inputs":[]},{"name":"WalletCap","type":"error","inputs":[]},{"name":"WrongPayment","type":"error","inputs":[]},{"name":"ZeroAddress","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":"BaseURIChanged","type":"event","inputs":[{"name":"newBaseURI","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"BatchMetadataUpdate","type":"event","inputs":[{"name":"_fromTokenId","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_toTokenId","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MetadataFrozen","type":"event","inputs":[{"name":"finalBaseURI","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"Minted","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"firstId","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"qty","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"paid","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferStarted","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"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":"PriceChanged","type":"event","inputs":[{"name":"oldPrice","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newPrice","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"Withdrawn","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"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":"contractURI","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"costFor","type":"function","inputs":[{"name":"who","type":"address","internalType":"address"},{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freezeMetadata","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"hasFreeMint","type":"function","inputs":[{"name":"who","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":"maxPerTx","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"maxPerWallet","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"maxPrice","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"maxSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"metadataFrozen","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"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":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pendingOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"price","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"remaining","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"reserve","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"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":"b","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPrice","type":"function","inputs":[{"name":"p","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"id","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":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","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":"treasury","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address payable"}],"stateMutability":"view"},{"name":"withdraw","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.24+commit.e11b9ed9"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address payable","name":"treasury_","type":"address"},{"internalType":"uint256","name":"maxSupply_","type":"uint256"},{"internalType":"uint256","name":"maxPerWallet_","type":"uint256"},{"internalType":"uint256","name":"maxPerTx_","type":"uint256"},{"internalType":"uint256","name":"reserve_","type":"uint256"},{"internalType":"uint256","name":"price_","type":"uint256"},{"internalType":"uint256","name":"maxPrice_","type":"uint256"},{"internalType":"string","name":"base_","type":"string"},{"internalType":"string","name":"contractURI__","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BadConfig","type":"error"},{"inputs":[],"name":"BadQty","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":"MetadataIsFrozen","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":"PriceTooHigh","type":"error"},{"inputs":[],"name":"SoldOut","type":"error"},{"inputs":[],"name":"WalletCap","type":"error"},{"inputs":[],"name":"WrongPayment","type":"error"},{"inputs":[],"name":"ZeroAddress","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":false,"internalType":"string","name":"newBaseURI","type":"string"}],"name":"BaseURIChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_toTokenId","type":"uint256"}],"name":"BatchMetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"finalBaseURI","type":"string"}],"name":"MetadataFrozen","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":"qty","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"paid","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":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"PriceChanged","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","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":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"who","type":"address"},{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"costFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freezeMetadata","outputs":[],"stateMutability":"nonpayable","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":"who","type":"address"}],"name":"hasFreeMint","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":[],"name":"maxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"metadataFrozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","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":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remaining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reserve","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":"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":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"b","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"p","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"id","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":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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":"treasury","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"author":"Cogito Agents — https://cogitoagents.pages.dev — X @CogitoAgents","details":"Owner powers are ONLY: setPrice (bounded by immutable maxPrice), setBaseURI (until freezeMetadata(), then never),      freezeMetadata, and transfer/renounce ownership (Ownable2Step).      No blacklist, no pause, no transfer restrictions, no owner mint (beyond an optional reserve fixed at deploy; default 0).      No royalties (no ERC-2981). Proceeds accumulate in the contract; withdraw() is callable by anyone and pays ONLY the immutable treasury.","errors":{"ERC721IncorrectOwner(address,uint256,address)":[{"details":"Indicates an error related to the ownership over a particular token. Used in transfers.","params":{"owner":"Address of the current owner of a token.","sender":"Address whose tokens are being transferred.","tokenId":"Identifier number of a token."}}],"ERC721InsufficientApproval(address,uint256)":[{"details":"Indicates a failure with the `operator`’s approval. Used in transfers.","params":{"operator":"Address that may be allowed to operate on tokens without being their owner.","tokenId":"Identifier number of a token."}}],"ERC721InvalidApprover(address)":[{"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals.","params":{"approver":"Address initiating an approval operation."}}],"ERC721InvalidOperator(address)":[{"details":"Indicates a failure with the `operator` to be approved. Used in approvals.","params":{"operator":"Address that may be allowed to operate on tokens without being their owner."}}],"ERC721InvalidOwner(address)":[{"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. Used in balance queries.","params":{"owner":"Address of the current owner of a token."}}],"ERC721InvalidReceiver(address)":[{"details":"Indicates a failure with the token `receiver`. Used in transfers.","params":{"receiver":"Address to which tokens are being transferred."}}],"ERC721InvalidSender(address)":[{"details":"Indicates a failure with the token `sender`. Used in transfers.","params":{"sender":"Address whose tokens are being transferred."}}],"ERC721NonexistentToken(uint256)":[{"details":"Indicates a `tokenId` whose `owner` is the zero address.","params":{"tokenId":"Identifier number of a token."}}],"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."}]},"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."},"BatchMetadataUpdate(uint256,uint256)":{"details":"EIP-4906"},"Transfer(address,address,uint256)":{"details":"Emitted when `tokenId` token is transferred from `from` to `to`."}},"kind":"dev","methods":{"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"approve(address,uint256)":{"details":"Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event."},"balanceOf(address)":{"details":"Returns the number of tokens in ``owner``'s account."},"costFor(address,uint256)":{"params":{"who":"Minting address. @param qty Number of NFTs."}},"getApproved(uint256)":{"details":"Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist."},"isApprovedForAll(address,address)":{"details":"Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}"},"mint(uint256)":{"details":"msg.value must EQUAL costFor(msg.sender, qty): price()*(qty-1) if the sender has never minted, else price()*qty.      Reverts: BadQty (0 or > maxPerTx), SoldOut, WalletCap (> maxPerWallet total), WrongPayment (any other value).      Free first mint example: mint(1) with value 0 — calldata 0xa0712d68 + uint256(1).","params":{"qty":"Number of NFTs (1..maxPerTx)."}},"name()":{"details":"Returns the token collection name."},"owner()":{"details":"Returns the address of the current owner."},"ownerOf(uint256)":{"details":"Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist."},"pendingOwner()":{"details":"Returns the address of the pending owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"safeTransferFrom(address,address,uint256)":{"details":"Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or   {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."},"setApprovalForAll(address,bool)":{"details":"Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the address zero. Emits an {ApprovalForAll} event."},"supportsInterface(bytes4)":{"details":"ERC-165 incl. EIP-4906 (0x49064906)."},"symbol()":{"details":"Returns the token collection symbol."},"tokenURI(uint256)":{"details":"Returns the Uniform Resource Identifier (URI) for `tokenId` token."},"transferFrom(address,address,uint256)":{"details":"Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event."},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer."}},"title":"Cogito Agents (COG-A) — AI-agent-first NFT on BNB Chain","version":1},"userdoc":{"events":{"Minted(address,uint256,uint256,uint256)":{"notice":"Emitted on every mint. paid == wei paid (0 for a free first mint)."}},"kind":"user","methods":{"contractURI()":{"notice":"Collection-level metadata (name, description, image, external_link) for marketplaces/indexers. Fixed at deploy."},"costFor(address,uint256)":{"notice":"Exact wei `who` must send to mint `qty` right now (includes the free first NFT). Returns 0 for qty 0."},"freezeMetadata()":{"notice":"Permanently locks the base URI. Irreversible."},"hasFreeMint(address)":{"notice":"True if `who` has never minted, i.e. its next NFT is free."},"maxPerTx()":{"notice":"Max NFTs per mint() call."},"maxPerWallet()":{"notice":"Max NFTs any single address can mint over its lifetime."},"maxPrice()":{"notice":"Ceiling for price(); setPrice can never exceed it."},"maxSupply()":{"notice":"Hard cap on total NFTs."},"metadataFrozen()":{"notice":"True once freezeMetadata() was called; baseURI can never change afterwards."},"mint(uint256)":{"notice":"Mint `qty` NFTs to msg.sender."},"mintedBy(address)":{"notice":"NFTs minted by each address (0 => its next NFT is free)."},"price()":{"notice":"Current price in wei for each NFT after a wallet's free first one."},"remaining()":{"notice":"NFTs still mintable before sold out."},"reserve()":{"notice":"NFTs minted to the deployer at deploy (ids 1..reserve). Default deploy uses 0."},"setBaseURI(string)":{"notice":"Owner may change the metadata base URI until freezeMetadata() is called."},"setPrice(uint256)":{"notice":"Owner may adjust the price to track ~US$0.50 as BNB moves. Can never exceed immutable maxPrice."},"totalSupply()":{"notice":"NFTs minted so far (token ids are 1..totalSupply)."},"treasury()":{"notice":"The only address withdraw() can pay."},"withdraw()":{"notice":"Anyone may call; the full balance goes only to the immutable treasury."}},"notice":"HOW TO MINT (agents): 1) v = costFor(you, qty)  2) mint(qty) with msg.value == v exactly.         Each wallet's FIRST NFT is free (gas only); every further NFT costs price() wei. Max maxPerWallet() per wallet.         Machine-readable docs: https://cogitoagents.pages.dev/llms.txt and /mint.json","version":1}},"settings":{"compilationTarget":{"contracts/CogitoAgentsV2.sol":"CogitoAgentsV2"},"evmVersion":"cancun","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/access/Ownable2Step.sol":{"keccak256":"0xdcad8898fda432696597752e8ec361b87d85c82cb258115427af006dacf7128c","license":"MIT","urls":["bzz-raw://e2c9d517f0c136d54bd00cd57959d25681d4d6273f5bbbc263afe228303772f0","dweb:/ipfs/QmReNFjXBiufByiAAzfSQ2SM5r3qeUErn46BmN3yVRvrek"]},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"keccak256":"0x1b88b3fb3d85ba5496d7d5f396f83ee1fddcdd6762059ff65992655b67920998","license":"MIT","urls":["bzz-raw://89393bb3212da1c0889601b9706a07b39419ddc4d2faab9eaf6e7f9152cf6a1c","dweb:/ipfs/QmcCfzzxv1Bkdz1c1yF4gQCeYb6Us5BJANnzTFqawfd1HL"]},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"keccak256":"0xf6bb0dc431a9c50e25756412ec14cfcd4dc61dd40b8dc0e1b58ec09fce6d5564","license":"MIT","urls":["bzz-raw://eb87fef7e8ed754b8600cd5d42e4f23128059006368ffd19e4d50cc166471ee5","dweb:/ipfs/Qmc1vy1cevKreGUsG7S79gyhNvDtPnNz9qG47eYVHmMKLs"]},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"keccak256":"0xf78f05f3b8c9f75570e85300d7b4600d7f6f6a198449273f31d44c1641adb46f","license":"MIT","urls":["bzz-raw://e28b872613b45e0e801d4995aa4380be2531147bfe2d85c1d6275f1de514fba3","dweb:/ipfs/QmeeFcfShHYaS3BdgVj78nxR28ZaVUwbvr66ud8bT6kzw9"]},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"keccak256":"0x88cd5e3bee2e8c36b8d9058fbcaa81ad5704281b25634122234b55ea853d8055","license":"MIT","urls":["bzz-raw://8dc7e7ab5b8ea36c15027ab04221b05d1c970f47a53e9fd47ead8ca665d49c7e","dweb:/ipfs/Qmeeph7fsDyfRr8vb2L8KcDEmKPb224TAayMvgqgGAnqpL"]},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"keccak256":"0xf46268c37522320bb2119a5a394bc5c739a95c0c574c8d08e8c643f4d06e5c76","license":"MIT","urls":["bzz-raw://517e4b295f35b9947c72ad7379a6089439ece7bb6f4a2ea0a159da13046c039e","dweb:/ipfs/QmZXzkSfLUbvujig3zVbpDHykpHhqLpvQtdiN3B5j4TA3u"]},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"keccak256":"0xc7efbc23214ad7dced8bf2249460f4bda114d57f6a0079f84040654280f455bd","license":"MIT","urls":["bzz-raw://1f5bd44efca8c8c0d74439e7b808d1f9c4af1df78f91fef8e8bbca8104645435","dweb:/ipfs/Qmb42XSd8MKsEitp42sZkSFGqDRigk6QgGXtiJyJqUZJJ6"]},"@openzeppelin/contracts/utils/Bytes.sol":{"keccak256":"0xf80e4b96b6849936ea0fabd76cf81b13d7276295fddb1e1c07afb3ddf650b0ac","license":"MIT","urls":["bzz-raw://6430007255ac11c6e9c4331a418f3af52ff66fbbae959f645301d025b20aeb08","dweb:/ipfs/QmQE5fjmBBRw9ndnzJuC2uskYss1gbaR7JdazoCf1FGoBj"]},"@openzeppelin/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"@openzeppelin/contracts/utils/Panic.sol":{"keccak256":"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a","license":"MIT","urls":["bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a","dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG"]},"@openzeppelin/contracts/utils/Strings.sol":{"keccak256":"0x1fdc2de9585ab0f1c417f02a873a2b6343cd64bb7ffec6b00ffa11a4a158d9e8","license":"MIT","urls":["bzz-raw://1ab223a3d969c6cd7610049431dd42740960c477e45878f5d8b54411f7a32bdc","dweb:/ipfs/QmWumhjvhpKcwx3vDPQninsNVTc3BGvqaihkQakFkQYpaS"]},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"keccak256":"0x2d9dc2fe26180f74c11c13663647d38e259e45f95eb88f57b61d2160b0109d3e","license":"MIT","urls":["bzz-raw://81233d1f98060113d9922180bb0f14f8335856fe9f339134b09335e9f678c377","dweb:/ipfs/QmWh6R35SarhAn4z2wH8SU456jJSYL2FgucfTFgbHJJN4E"]},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c","license":"MIT","urls":["bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617","dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u"]},"@openzeppelin/contracts/utils/math/Math.sol":{"keccak256":"0x59973a93b1f983f94e10529f46ca46544a9fec2b5f56fb1390bbe9e0dc79f857","license":"MIT","urls":["bzz-raw://c55ef8f0b9719790c2ae6f81d80a59ffb89f2f0abe6bc065585bd79edce058c5","dweb:/ipfs/QmNNmCbX9NjPXKqHJN8R1WC2rNeZSQrPZLd6FF6AKLyH5Y"]},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"keccak256":"0xc8cae21c9ae4a46e5162ff9bf5b351d6fa6a6eba72d515f3bc1bdfeda7fdf083","license":"MIT","urls":["bzz-raw://ce830ebcf28e31643caba318996db3763c36d52cd0f23798ba83c135355d45e9","dweb:/ipfs/QmdGPcvptHN7UBCbUYBbRX3hiRVRFLRwno8b4uga6uFNif"]},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"keccak256":"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3","license":"MIT","urls":["bzz-raw://db5fbb3dddd8b7047465b62575d96231ba8a2774d37fb4737fbf23340fabbb03","dweb:/ipfs/QmVUSvooZKEdEdap619tcJjTLcAuH6QBdZqAzWwnAXZAWJ"]},"contracts/CogitoAgentsV2.sol":{"keccak256":"0x8639d1cb86eadd96ca29ef90e023f0519089a7aea9219a2c1423acc6ebcdce51","license":"MIT","urls":["bzz-raw://ba011d3bfcd087d4e9040be126893ed16ca37a2427a9ec94ff7b7b573ab8ce2a","dweb:/ipfs/QmTsVxacGFZ4gqDkfJQDJENkfaGEQa7oesYT13h7bg4KWa"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_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":403,"label":"_name","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"1","type":"t_string_storage","astId":405,"label":"_symbol","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"2","type":"t_mapping(t_uint256,t_address)","astId":409,"label":"_owners","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"3","type":"t_mapping(t_address,t_uint256)","astId":413,"label":"_balances","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"4","type":"t_mapping(t_uint256,t_address)","astId":417,"label":"_tokenApprovals","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"5","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":423,"label":"_operatorApprovals","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"6","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"7","type":"t_address","astId":156,"label":"_pendingOwner","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"8","type":"t_uint256","astId":7610,"label":"price","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"9","type":"t_uint256","astId":7613,"label":"totalSupply","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"10","type":"t_mapping(t_address,t_uint256)","astId":7618,"label":"mintedBy","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"11","type":"t_string_storage","astId":7620,"label":"baseURI_","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"12","type":"t_bool","astId":7623,"label":"metadataFrozen","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"13","type":"t_string_storage","astId":7625,"label":"contractURI_","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","events":{"Minted(address,uint256,uint256,uint256)":{"notice":"Emitted on every mint. paid == wei paid (0 for a free first mint)."}},"notice":"HOW TO MINT (agents): 1) v = costFor(you, qty)  2) mint(qty) with msg.value == v exactly.         Each wallet's FIRST NFT is free (gas only); every further NFT costs price() wei. Max maxPerWallet() per wallet.         Machine-readable docs: https://cogitoagents.pages.dev/llms.txt and /mint.json","methods":{"price()":{"notice":"Current price in wei for each NFT after a wallet's free first one."},"reserve()":{"notice":"NFTs minted to the deployer at deploy (ids 1..reserve). Default deploy uses 0."},"maxPerTx()":{"notice":"Max NFTs per mint() call."},"maxPrice()":{"notice":"Ceiling for price(); setPrice can never exceed it."},"treasury()":{"notice":"The only address withdraw() can pay."},"withdraw()":{"notice":"Anyone may call; the full balance goes only to the immutable treasury."},"maxSupply()":{"notice":"Hard cap on total NFTs."},"remaining()":{"notice":"NFTs still mintable before sold out."},"contractURI()":{"notice":"Collection-level metadata (name, description, image, external_link) for marketplaces/indexers. Fixed at deploy."},"mint(uint256)":{"notice":"Mint `qty` NFTs to msg.sender."},"totalSupply()":{"notice":"NFTs minted so far (token ids are 1..totalSupply)."},"maxPerWallet()":{"notice":"Max NFTs any single address can mint over its lifetime."},"freezeMetadata()":{"notice":"Permanently locks the base URI. Irreversible."},"metadataFrozen()":{"notice":"True once freezeMetadata() was called; baseURI can never change afterwards."},"mintedBy(address)":{"notice":"NFTs minted by each address (0 => its next NFT is free)."},"setPrice(uint256)":{"notice":"Owner may adjust the price to track ~US$0.50 as BNB moves. Can never exceed immutable maxPrice."},"setBaseURI(string)":{"notice":"Owner may change the metadata base URI until freezeMetadata() is called."},"hasFreeMint(address)":{"notice":"True if `who` has never minted, i.e. its next NFT is free."},"costFor(address,uint256)":{"notice":"Exact wei `who` must send to mint `qty` right now (includes the free first NFT). Returns 0 for qty 0."}},"version":1},"devdoc":{"kind":"dev","title":"Cogito Agents (COG-A) — AI-agent-first NFT on BNB Chain","author":"Cogito Agents — https://cogitoagents.pages.dev — X @CogitoAgents","errors":{"ERC721InvalidOwner(address)":[{"params":{"owner":"Address of the current owner of a token."},"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. Used in balance queries."}],"ERC721InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"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."}],"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."},"BatchMetadataUpdate(uint256,uint256)":{"details":"EIP-4906"}},"details":"Owner powers are ONLY: setPrice (bounded by immutable maxPrice), setBaseURI (until freezeMetadata(), then never),      freezeMetadata, and transfer/renounce ownership (Ownable2Step).      No blacklist, no pause, no transfer restrictions, no owner mint (beyond an optional reserve fixed at deploy; default 0).      No royalties (no ERC-2981). Proceeds accumulate in the contract; withdraw() is callable by anyone and pays ONLY the immutable treasury.","methods":{"name()":{"details":"Returns the token collection name."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the token collection symbol."},"mint(uint256)":{"params":{"qty":"Number of NFTs (1..maxPerTx)."},"details":"msg.value must EQUAL costFor(msg.sender, qty): price()*(qty-1) if the sender has never minted, else price()*qty.      Reverts: BadQty (0 or > maxPerTx), SoldOut, WalletCap (> maxPerWallet total), WrongPayment (any other value).      Free first mint example: mint(1) with value 0 — calldata 0xa0712d68 + uint256(1)."},"pendingOwner()":{"details":"Returns the address of the pending owner."},"ownerOf(uint256)":{"details":"Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"tokenURI(uint256)":{"details":"Returns the Uniform Resource Identifier (URI) for `tokenId` token."},"balanceOf(address)":{"details":"Returns the number of tokens in ``owner``'s account."},"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":"Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist."},"approve(address,uint256)":{"details":"Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event."},"costFor(address,uint256)":{"params":{"who":"Minting address. @param qty Number of NFTs."}},"supportsInterface(bytes4)":{"details":"ERC-165 incl. EIP-4906 (0x49064906)."},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer."},"setApprovalForAll(address,bool)":{"details":"Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the address zero. Emits an {ApprovalForAll} event."},"isApprovedForAll(address,address)":{"details":"Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}"},"transferFrom(address,address,uint256)":{"details":"Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256)":{"details":"Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or   {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."}},"version":1},"sourceIds":{"contracts/CogitoAgentsV2.sol":{"id":17},"@openzeppelin/contracts/utils/Bytes.sol":{"id":8},"@openzeppelin/contracts/utils/Panic.sol":{"id":10},"@openzeppelin/contracts/utils/Context.sol":{"id":9},"@openzeppelin/contracts/utils/Strings.sol":{"id":11},"@openzeppelin/contracts/access/Ownable.sol":{"id":0},"@openzeppelin/contracts/utils/math/Math.sol":{"id":14},"@openzeppelin/contracts/access/Ownable2Step.sol":{"id":1},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"id":3},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"id":15},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"id":4},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"id":16},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":2},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":12},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":13},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"id":5},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"id":7},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"id":6}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/CogitoAgentsV2.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {ERC721} from \"@openzeppelin/contracts/token/ERC721/ERC721.sol\";\nimport {Ownable2Step, Ownable} from \"@openzeppelin/contracts/access/Ownable2Step.sol\";\n\n/// @title Cogito Agents (COG-A) — AI-agent-first NFT on BNB Chain\n/// @author Cogito Agents — https://cogitoagents.pages.dev — X @CogitoAgents\n/// @notice HOW TO MINT (agents): 1) v = costFor(you, qty)  2) mint(qty) with msg.value == v exactly.\n///         Each wallet's FIRST NFT is free (gas only); every further NFT costs price() wei. Max maxPerWallet() per wallet.\n///         Machine-readable docs: https://cogitoagents.pages.dev/llms.txt and /mint.json\n/// @dev Owner powers are ONLY: setPrice (bounded by immutable maxPrice), setBaseURI (until freezeMetadata(), then never),\n///      freezeMetadata, and transfer/renounce ownership (Ownable2Step).\n///      No blacklist, no pause, no transfer restrictions, no owner mint (beyond an optional reserve fixed at deploy; default 0).\n///      No royalties (no ERC-2981). Proceeds accumulate in the contract; withdraw() is callable by anyone and pays ONLY the immutable treasury.\ncontract CogitoAgentsV2 is ERC721, Ownable2Step {\n    /// @notice Hard cap on total NFTs.\n    uint256 public immutable maxSupply;\n    /// @notice Max NFTs any single address can mint over its lifetime.\n    uint256 public immutable maxPerWallet;\n    /// @notice Max NFTs per mint() call.\n    uint256 public immutable maxPerTx;\n    /// @notice NFTs minted to the deployer at deploy (ids 1..reserve). Default deploy uses 0.\n    uint256 public immutable reserve;\n    /// @notice Ceiling for price(); setPrice can never exceed it.\n    uint256 public immutable maxPrice;\n    /// @notice The only address withdraw() can pay.\n    address payable public immutable treasury;\n\n    /// @notice Current price in wei for each NFT after a wallet's free first one.\n    uint256 public price;\n    /// @notice NFTs minted so far (token ids are 1..totalSupply).\n    uint256 public totalSupply;\n    /// @notice NFTs minted by each address (0 => its next NFT is free).\n    mapping(address => uint256) public mintedBy;\n    string private baseURI_;\n    /// @notice True once freezeMetadata() was called; baseURI can never change afterwards.\n    bool public metadataFrozen;\n    string private contractURI_;\n\n    /// @notice Emitted on every mint. paid == wei paid (0 for a free first mint).\n    event Minted(address indexed to, uint256 firstId, uint256 qty, uint256 paid);\n    event PriceChanged(uint256 oldPrice, uint256 newPrice);\n    event Withdrawn(address indexed to, uint256 amount);\n    /// @dev EIP-4906\n    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);\n    event BaseURIChanged(string newBaseURI);\n    event MetadataFrozen(string finalBaseURI);\n\n    error ZeroAddress();\n    error BadQty();\n    error SoldOut();\n    error WalletCap();\n    error WrongPayment();\n    error PriceTooHigh();\n    error BadConfig();\n    error MetadataIsFrozen();\n\n    constructor(\n        address payable treasury_, uint256 maxSupply_, uint256 maxPerWallet_, uint256 maxPerTx_,\n        uint256 reserve_, uint256 price_, uint256 maxPrice_, string memory base_, string memory contractURI__\n    ) ERC721(\"Cogito Agents\", \"COG-A\") Ownable(msg.sender) {\n        if (treasury_ == address(0)) revert ZeroAddress();\n        if (maxSupply_ == 0 || reserve_ > maxSupply_ || maxPerWallet_ == 0 || maxPerTx_ == 0 || price_ > maxPrice_) revert BadConfig();\n        treasury = treasury_; maxSupply = maxSupply_; maxPerWallet = maxPerWallet_; maxPerTx = maxPerTx_;\n        reserve = reserve_; price = price_; maxPrice = maxPrice_; baseURI_ = base_; contractURI_ = contractURI__;\n        for (uint256 i = 1; i <= reserve_; i++) _mint(msg.sender, i);\n        totalSupply = reserve_;\n        if (reserve_ > 0) emit Minted(msg.sender, 1, reserve_, 0);\n    }\n\n    /// @notice Mint `qty` NFTs to msg.sender.\n    /// @dev msg.value must EQUAL costFor(msg.sender, qty): price()*(qty-1) if the sender has never minted, else price()*qty.\n    ///      Reverts: BadQty (0 or > maxPerTx), SoldOut, WalletCap (> maxPerWallet total), WrongPayment (any other value).\n    ///      Free first mint example: mint(1) with value 0 — calldata 0xa0712d68 + uint256(1).\n    /// @param qty Number of NFTs (1..maxPerTx).\n    function mint(uint256 qty) external payable {\n        if (qty == 0 || qty > maxPerTx) revert BadQty();\n        uint256 s = totalSupply;\n        if (s + qty > maxSupply) revert SoldOut();\n        uint256 prev = mintedBy[msg.sender];\n        uint256 m = prev + qty;\n        if (m > maxPerWallet) revert WalletCap();\n        if (msg.value != _cost(prev, qty)) revert WrongPayment();\n        mintedBy[msg.sender] = m;\n        totalSupply = s + qty;\n        for (uint256 i = 1; i <= qty; i++) _mint(msg.sender, s + i); // _mint (not _safeMint): no callback reentrancy\n        emit Minted(msg.sender, s + 1, qty, msg.value);\n    }\n\n    function _cost(uint256 prev, uint256 qty) internal view returns (uint256) {\n        return price * (prev == 0 ? qty - 1 : qty); // first NFT of a wallet is free\n    }\n\n    /// @notice Exact wei `who` must send to mint `qty` right now (includes the free first NFT). Returns 0 for qty 0.\n    /// @param who Minting address. @param qty Number of NFTs.\n    function costFor(address who, uint256 qty) external view returns (uint256) {\n        if (qty == 0) return 0;\n        return _cost(mintedBy[who], qty);\n    }\n\n    /// @notice True if `who` has never minted, i.e. its next NFT is free.\n    function hasFreeMint(address who) external view returns (bool) { return mintedBy[who] == 0; }\n\n    /// @notice NFTs still mintable before sold out.\n    function remaining() external view returns (uint256) { return maxSupply - totalSupply; }\n\n    /// @notice Collection-level metadata (name, description, image, external_link) for marketplaces/indexers. Fixed at deploy.\n    function contractURI() external view returns (string memory) { return contractURI_; }\n\n    /// @notice Owner may adjust the price to track ~US$0.50 as BNB moves. Can never exceed immutable maxPrice.\n    function setPrice(uint256 p) external onlyOwner {\n        if (p > maxPrice) revert PriceTooHigh();\n        emit PriceChanged(price, p);\n        price = p;\n    }\n\n    /// @notice Anyone may call; the full balance goes only to the immutable treasury.\n    function withdraw() external {\n        uint256 bal = address(this).balance;\n        (bool ok, ) = treasury.call{value: bal}(\"\");\n        require(ok, \"transfer failed\");\n        emit Withdrawn(treasury, bal);\n    }\n\n    /// @notice Owner may change the metadata base URI until freezeMetadata() is called.\n    function setBaseURI(string calldata b) external onlyOwner {\n        if (metadataFrozen) revert MetadataIsFrozen();\n        baseURI_ = b;\n        emit BaseURIChanged(b);\n        emit BatchMetadataUpdate(1, maxSupply); // token ids are 1..maxSupply\n    }\n\n    /// @notice Permanently locks the base URI. Irreversible.\n    function freezeMetadata() external onlyOwner {\n        if (metadataFrozen) revert MetadataIsFrozen();\n        metadataFrozen = true;\n        emit MetadataFrozen(baseURI_);\n    }\n\n    /// @dev ERC-165 incl. EIP-4906 (0x49064906).\n    function supportsInterface(bytes4 id) public view override returns (bool) {\n        return id == bytes4(0x49064906) || super.supportsInterface(id);\n    }\n\n    function _baseURI() internal view override returns (string memory) { return baseURI_; }\n}\n"},"@openzeppelin/contracts/utils/Bytes.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/Bytes.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\n\n/**\n * @dev Bytes operations.\n */\nlibrary Bytes {\n    /**\n     * @dev Forward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the first instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return indexOf(buffer, s, 0);\n    }\n\n    /**\n     * @dev Forward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or after `pos`), returns the index of the next instance\n     * * If `s` is not present in the buffer (at or after `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        uint256 length = buffer.length;\n        for (uint256 i = pos; i < length; ++i) {\n            if (bytes1(_unsafeReadBytesOffset(buffer, i)) == s) {\n                return i;\n            }\n        }\n        return type(uint256).max;\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the last instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return lastIndexOf(buffer, s, type(uint256).max);\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or before `pos`), returns the index of the previous instance\n     * * If `s` is not present in the buffer (at or before `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        unchecked {\n            uint256 length = buffer.length;\n            for (uint256 i = Math.min(Math.saturatingAdd(pos, 1), length); i > 0; --i) {\n                if (bytes1(_unsafeReadBytesOffset(buffer, i - 1)) == s) {\n                    return i - 1;\n                }\n            }\n            return type(uint256).max;\n        }\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to the end of `buffer` into a new bytes object in\n     * memory.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return slice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to `end` (excluded) into a new bytes object in\n     * memory. The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // allocate and copy\n        bytes memory result = new bytes(end - start);\n        assembly (\"memory-safe\") {\n            mcopy(add(result, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to the end of `buffer` to the start of that buffer,\n     * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:].\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     */\n    function splice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return splice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to `end` (excluded) to the start of that buffer,\n     * and shrinks the buffer length accordingly, effectively overriding the content of buffer with buffer[start:end].\n     * The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     */\n    function splice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // move and resize\n        assembly (\"memory-safe\") {\n            mcopy(add(buffer, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n            mstore(buffer, sub(end, start))\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Replaces bytes in `buffer` starting at `pos` with all bytes from `replacement`.\n     *\n     * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`).\n     * If `pos >= buffer.length`, no replacement occurs and the buffer is returned unchanged.\n     *\n     * NOTE: This function modifies the provided buffer in place.\n     */\n    function replace(bytes memory buffer, uint256 pos, bytes memory replacement) internal pure returns (bytes memory) {\n        return replace(buffer, pos, replacement, 0, replacement.length);\n    }\n\n    /**\n     * @dev Replaces bytes in `buffer` starting at `pos` with bytes from `replacement` starting at `offset`.\n     * Copies at most `length` bytes from `replacement` to `buffer`.\n     *\n     * Parameters are clamped to valid ranges (i.e. `pos` is clamped to `[0, buffer.length]`, `offset` is\n     * clamped to `[0, replacement.length]`, and `length` is clamped to `min(length, replacement.length - offset,\n     * buffer.length - pos))`. If `pos >= buffer.length` or `offset >= replacement.length`, no replacement occurs\n     * and the buffer is returned unchanged.\n     *\n     * NOTE: This function modifies the provided buffer in place.\n     */\n    function replace(\n        bytes memory buffer,\n        uint256 pos,\n        bytes memory replacement,\n        uint256 offset,\n        uint256 length\n    ) internal pure returns (bytes memory) {\n        // sanitize\n        pos = Math.min(pos, buffer.length);\n        offset = Math.min(offset, replacement.length);\n        length = Math.min(length, Math.min(replacement.length - offset, buffer.length - pos));\n\n        // replace\n        assembly (\"memory-safe\") {\n            mcopy(add(add(buffer, 0x20), pos), add(add(replacement, 0x20), offset), length)\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Concatenate an array of bytes into a single bytes object.\n     *\n     * For fixed bytes types, we recommend using the solidity built-in `bytes.concat` or (equivalent)\n     * `abi.encodePacked`.\n     *\n     * NOTE: this could be done in assembly with a single loop that expands starting at the FMP, but that would be\n     * significantly less readable. It might be worth benchmarking the savings of the full-assembly approach.\n     */\n    function concat(bytes[] memory buffers) internal pure returns (bytes memory) {\n        uint256 length = 0;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            length += buffers[i].length;\n        }\n\n        bytes memory result = new bytes(length);\n\n        uint256 offset = 0x20;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            bytes memory input = buffers[i];\n            assembly (\"memory-safe\") {\n                mcopy(add(result, offset), add(input, 0x20), mload(input))\n            }\n            unchecked {\n                offset += input.length;\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Split each byte in `input` into two nibbles (4 bits each)\n     *\n     * Example: hex\"01234567\" → hex\"0001020304050607\"\n     */\n    function toNibbles(bytes memory input) internal pure returns (bytes memory output) {\n        assembly (\"memory-safe\") {\n            let length := mload(input)\n            output := mload(0x40)\n            mstore(0x40, add(add(output, 0x20), mul(length, 2)))\n            mstore(output, mul(length, 2))\n            for {\n                let i := 0\n            } lt(i, length) {\n                i := add(i, 0x10)\n            } {\n                let chunk := shr(128, mload(add(add(input, 0x20), i)))\n                chunk := and(\n                    0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff,\n                    or(shl(64, chunk), chunk)\n                )\n                chunk := and(\n                    0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff,\n                    or(shl(32, chunk), chunk)\n                )\n                chunk := and(\n                    0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff,\n                    or(shl(16, chunk), chunk)\n                )\n                chunk := and(\n                    0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff,\n                    or(shl(8, chunk), chunk)\n                )\n                chunk := and(\n                    0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f,\n                    or(shl(4, chunk), chunk)\n                )\n                mstore(add(add(output, 0x20), mul(i, 2)), chunk)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns true if the two byte buffers are equal.\n     */\n    function equal(bytes memory a, bytes memory b) internal pure returns (bool) {\n        return a.length == b.length && keccak256(a) == keccak256(b);\n    }\n\n    /**\n     * @dev Reverses the byte order of a bytes32 value, converting between little-endian and big-endian.\n     * Inspired by https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel[Reverse Parallel]\n     */\n    function reverseBytes32(bytes32 value) internal pure returns (bytes32) {\n        value = // swap bytes\n            ((value >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        value = // swap 8-byte long pairs\n            ((value >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |\n            ((value & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);\n        return (value >> 128) | (value << 128); // swap 16-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 128-bit values.\n    function reverseBytes16(bytes16 value) internal pure returns (bytes16) {\n        value = // swap bytes\n            ((value & 0xFF00FF00FF00FF00FF00FF00FF00FF00) >> 8) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value & 0xFFFF0000FFFF0000FFFF0000FFFF0000) >> 16) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value & 0xFFFFFFFF00000000FFFFFFFF00000000) >> 32) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        return (value >> 64) | (value << 64); // swap 8-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 64-bit values.\n    function reverseBytes8(bytes8 value) internal pure returns (bytes8) {\n        value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8); // swap bytes\n        value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16); // swap 2-byte long pairs\n        return (value >> 32) | (value << 32); // swap 4-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 32-bit values.\n    function reverseBytes4(bytes4 value) internal pure returns (bytes4) {\n        value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); // swap bytes\n        return (value >> 16) | (value << 16); // swap 2-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 16-bit values.\n    function reverseBytes2(bytes2 value) internal pure returns (bytes2) {\n        return (value >> 8) | (value << 8);\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits a bytes array. Returns `8 * buffer.length`\n     * if the buffer is all zeros.\n     */\n    function clz(bytes memory buffer) internal pure returns (uint256) {\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            bytes32 chunk = _unsafeReadBytesOffset(buffer, i);\n            if (chunk != bytes32(0)) {\n                return Math.min(8 * i + Math.clz(uint256(chunk)), 8 * buffer.length);\n            }\n        }\n        return 8 * buffer.length;\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n *\n * _Available since v5.1._\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/Strings.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SafeCast} from \"./math/SafeCast.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\nimport {Bytes} from \"./Bytes.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    using SafeCast for *;\n\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n    uint256 private constant SPECIAL_CHARS_LOOKUP =\n        0xffffffff | // first 32 bits corresponding to the control characters (U+0000 to U+001F)\n            (1 << 0x22) | // double quote\n            (1 << 0x5c); // backslash\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev The string being parsed contains characters that are not in scope of the given base.\n     */\n    error StringsInvalidChar();\n\n    /**\n     * @dev The string being parsed is not a properly formatted address.\n     */\n    error StringsInvalidAddressFormat();\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            assembly (\"memory-safe\") {\n                ptr := add(add(buffer, 0x20), length)\n            }\n            while (true) {\n                ptr--;\n                assembly (\"memory-safe\") {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `bytes` buffer to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(bytes memory input) internal pure returns (string memory) {\n        unchecked {\n            bytes memory buffer = new bytes(2 * input.length + 2);\n            buffer[0] = \"0\";\n            buffer[1] = \"x\";\n            for (uint256 i = 0; i < input.length; ++i) {\n                uint8 v = uint8(input[i]);\n                buffer[2 * i + 2] = HEX_DIGITS[v >> 4];\n                buffer[2 * i + 3] = HEX_DIGITS[v & 0xf];\n            }\n            return string(buffer);\n        }\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return Bytes.equal(bytes(a), bytes(b));\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input) internal pure returns (uint256) {\n        return parseUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        uint256 result = 0;\n        for (uint256 i = begin; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 9) return (false, 0);\n            result *= 10;\n            result += chr;\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `int256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input) internal pure returns (int256) {\n        return parseInt(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {\n        (bool success, int256 value) = tryParseInt(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if\n     * the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {\n        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    uint256 private constant ABS_MIN_INT256 = 2 ** 255;\n\n    /**\n     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character or if the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, int256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseIntUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseIntUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, int256 value) {\n        bytes memory buffer = bytes(input);\n\n        // Check presence of a negative sign.\n        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        bool positiveSign = sign == bytes1(\"+\");\n        bool negativeSign = sign == bytes1(\"-\");\n        uint256 offset = (positiveSign || negativeSign).toUint();\n\n        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);\n\n        if (absSuccess && absValue < ABS_MIN_INT256) {\n            return (true, negativeSign ? -int256(absValue) : int256(absValue));\n        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {\n            return (true, type(int256).min);\n        } else return (false, 0);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input) internal pure returns (uint256) {\n        return parseHexUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseHexUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an\n     * invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseHexUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseHexUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        // skip 0x prefix if present\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 offset = hasPrefix.toUint() * 2;\n\n        uint256 result = 0;\n        for (uint256 i = begin + offset; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 15) return (false, 0);\n            result *= 16;\n            unchecked {\n                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).\n                // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.\n                result += chr;\n            }\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as an `address`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input) internal pure returns (address) {\n        return parseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {\n        (bool success, address value) = tryParseAddress(input, begin, end);\n        if (!success) revert StringsInvalidAddressFormat();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly\n     * formatted address. See {parseAddress-string} requirements.\n     */\n    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {\n        return tryParseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly\n     * formatted address. See {parseAddress-string-uint256-uint256} requirements.\n     */\n    function tryParseAddress(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, address value) {\n        if (end > bytes(input).length || begin > end) return (false, address(0));\n\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;\n\n        // check that input is the correct length\n        if (end - begin == expectedLength) {\n            // length guarantees that this does not overflow, and value is at most type(uint160).max\n            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);\n            return (s, address(uint160(v)));\n        } else {\n            return (false, address(0));\n        }\n    }\n\n    function _tryParseChr(bytes1 chr) private pure returns (uint8) {\n        uint8 value = uint8(chr);\n\n        // Try to parse `chr`:\n        // - Case 1: [0-9]\n        // - Case 2: [a-f]\n        // - Case 3: [A-F]\n        // - otherwise not supported\n        unchecked {\n            if (value > 47 && value < 58) value -= 48;\n            else if (value > 96 && value < 103) value -= 87;\n            else if (value > 64 && value < 71) value -= 55;\n            else return type(uint8).max;\n        }\n\n        return value;\n    }\n\n    /**\n     * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.\n     *\n     * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.\n     *\n     * NOTE: This function escapes backslashes (including those in \\uXXXX sequences) and the characters in ranges\n     * defined in section 2.5 of RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). All control characters in U+0000\n     * to U+001F are escaped (\\b, \\t, \\n, \\f, \\r use short form; others use \\u00XX). ECMAScript's `JSON.parse` does\n     * recover escaped unicode characters that are not in this range, but other tooling may provide different results.\n     */\n    function escapeJSON(string memory input) internal pure returns (string memory) {\n        bytes memory buffer = bytes(input);\n\n        // Put output at the FMP. Memory will be reserved later when we figure out the actual length of the escaped\n        // string. All write are done using _unsafeWriteBytesOffset, which avoid the (expensive) length checks for\n        // each character written.\n        bytes memory output;\n        assembly (\"memory-safe\") {\n            output := mload(0x40)\n        }\n        uint256 outputLength = 0;\n\n        for (uint256 i = 0; i < buffer.length; ++i) {\n            uint8 char = uint8(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (((SPECIAL_CHARS_LOOKUP & (1 << char)) != 0)) {\n                _unsafeWriteBytesOffset(output, outputLength++, \"\\\\\");\n                if (char == 0x08) _unsafeWriteBytesOffset(output, outputLength++, \"b\");\n                else if (char == 0x09) _unsafeWriteBytesOffset(output, outputLength++, \"t\");\n                else if (char == 0x0a) _unsafeWriteBytesOffset(output, outputLength++, \"n\");\n                else if (char == 0x0c) _unsafeWriteBytesOffset(output, outputLength++, \"f\");\n                else if (char == 0x0d) _unsafeWriteBytesOffset(output, outputLength++, \"r\");\n                else if (char == 0x5c) _unsafeWriteBytesOffset(output, outputLength++, \"\\\\\");\n                else if (char == 0x22) {\n                    // solhint-disable-next-line quotes\n                    _unsafeWriteBytesOffset(output, outputLength++, '\"');\n                } else {\n                    // U+0000 to U+001F without short form: output \\u00XX\n                    _unsafeWriteBytesOffset(output, outputLength++, \"u\");\n                    _unsafeWriteBytesOffset(output, outputLength++, \"0\");\n                    _unsafeWriteBytesOffset(output, outputLength++, \"0\");\n                    _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char >> 4]);\n                    _unsafeWriteBytesOffset(output, outputLength++, HEX_DIGITS[char & 0x0f]);\n                }\n            } else {\n                _unsafeWriteBytesOffset(output, outputLength++, bytes1(char));\n            }\n        }\n        // write the actual length and reserve memory\n        assembly (\"memory-safe\") {\n            mstore(output, outputLength)\n            mstore(0x40, add(output, add(outputLength, 0x20)))\n        }\n\n        return string(output);\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n\n    /**\n     * @dev Write a bytes1 to a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeWriteBytesOffset(bytes memory buffer, uint256 offset, bytes1 value) private pure {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            mstore8(add(add(buffer, 0x20), offset), shr(248, value))\n        }\n    }\n}\n"},"@openzeppelin/contracts/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.6.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Return the 512-bit addition of two uint256.\n     *\n     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.\n     */\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        assembly (\"memory-safe\") {\n            low := add(a, b)\n            high := lt(low, a)\n        }\n    }\n\n    /**\n     * @dev Return the 512-bit multiplication of two uint256.\n     *\n     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.\n     */\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n        // variables such that product = high * 2²⁵⁶ + low.\n        assembly (\"memory-safe\") {\n            let mm := mulmod(a, b, not(0))\n            low := mul(a, b)\n            high := sub(sub(mm, low), lt(mm, low))\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            success = c >= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a - b;\n            success = c <= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a * b;\n            assembly (\"memory-safe\") {\n                // Only true when the multiplication doesn't overflow\n                // (c / a == b) || (a == 0)\n                success := or(eq(div(c, a), b), iszero(a))\n            }\n            // equivalent to: success ? c : 0\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `DIV` opcode returns zero when the denominator is 0.\n                result := div(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `MOD` opcode returns zero when the denominator is 0.\n                result := mod(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryAdd(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\n     */\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\n        (, uint256 result) = trySub(a, b);\n        return result;\n    }\n\n    /**\n     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryMul(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // (a + b) / 2 can overflow.\n            return (a & b) + (a ^ b) / 2;\n        }\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (high == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return low / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= high) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [high low].\n            uint256 remainder;\n            assembly (\"memory-safe\") {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                high := sub(high, gt(remainder, low))\n                low := sub(low, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly (\"memory-safe\") {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [high low] by twos.\n                low := div(low, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from high into low.\n            low |= high * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high\n            // is no longer required.\n            result = low * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n            if (high >= 1 << n) {\n                Panic.panic(Panic.UNDER_OVERFLOW);\n            }\n            return (high << (256 - n)) | (low >> n);\n        }\n    }\n\n    /**\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory buffer) private pure returns (bool) {\n        uint256 chunk;\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            // See _unsafeReadBytesOffset from utils/Bytes.sol\n            assembly (\"memory-safe\") {\n                chunk := mload(add(add(buffer, 0x20), i))\n            }\n            if (chunk >> (8 * saturatingSub(i + 0x20, buffer.length)) != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // If upper 8 bits of 16-bit half set, add 8 to result\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\n        // If upper 4 bits of 8-bit half set, add 4 to result\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\n\n        // Shifts value right by the current result and use it as an index into this lookup table:\n        //\n        // | x (4 bits) |  index  | table[index] = MSB position |\n        // |------------|---------|-----------------------------|\n        // |    0000    |    0    |        table[0] = 0         |\n        // |    0001    |    1    |        table[1] = 0         |\n        // |    0010    |    2    |        table[2] = 1         |\n        // |    0011    |    3    |        table[3] = 1         |\n        // |    0100    |    4    |        table[4] = 2         |\n        // |    0101    |    5    |        table[5] = 2         |\n        // |    0110    |    6    |        table[6] = 2         |\n        // |    0111    |    7    |        table[7] = 2         |\n        // |    1000    |    8    |        table[8] = 3         |\n        // |    1001    |    9    |        table[9] = 3         |\n        // |    1010    |   10    |        table[10] = 3        |\n        // |    1011    |   11    |        table[11] = 3        |\n        // |    1100    |   12    |        table[12] = 3        |\n        // |    1101    |   13    |        table[13] = 3        |\n        // |    1110    |   14    |        table[14] = 3        |\n        // |    1111    |   15    |        table[15] = 3        |\n        //\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the first 16 bytes (most significant half).\n        assembly (\"memory-safe\") {\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits in a uint256.\n     */\n    function clz(uint256 x) internal pure returns (uint256) {\n        return ternary(x == 0, 256, 255 - log2(x));\n    }\n}\n"},"@openzeppelin/contracts/access/Ownable2Step.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.20;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * This extension of the {Ownable} contract includes a two-step mechanism to transfer\n * ownership, where the new owner must call {acceptOwnership} in order to replace the\n * old one. This can help prevent common mistakes, such as transfers of ownership to\n * incorrect accounts, or to contracts that are unable to interact with the\n * permission system.\n *\n * The initial owner is specified at deployment time in the constructor for `Ownable`. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n    address private _pendingOwner;\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        return _pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     *\n     * Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        _pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        delete _pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        if (pendingOwner() != sender) {\n            revert OwnableUnauthorizedAccount(sender);\n        }\n        _transferOwnership(sender);\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (token/ERC721/ERC721.sol)\n\npragma solidity ^0.8.24;\n\nimport {IERC721} from \"./IERC721.sol\";\nimport {IERC721Metadata} from \"./extensions/IERC721Metadata.sol\";\nimport {ERC721Utils} from \"./utils/ERC721Utils.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {Strings} from \"../../utils/Strings.sol\";\nimport {IERC165, ERC165} from \"../../utils/introspection/ERC165.sol\";\nimport {IERC721Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\n * {ERC721Enumerable}.\n */\nabstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {\n    using Strings for uint256;\n\n    // Token name\n    string private _name;\n\n    // Token symbol\n    string private _symbol;\n\n    mapping(uint256 tokenId => address) private _owners;\n\n    mapping(address owner => uint256) private _balances;\n\n    mapping(uint256 tokenId => address) private _tokenApprovals;\n\n    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;\n\n    /**\n     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return\n            interfaceId == type(IERC721).interfaceId ||\n            interfaceId == type(IERC721Metadata).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /// @inheritdoc IERC721\n    function balanceOf(address owner) public view virtual returns (uint256) {\n        if (owner == address(0)) {\n            revert ERC721InvalidOwner(address(0));\n        }\n        return _balances[owner];\n    }\n\n    /// @inheritdoc IERC721\n    function ownerOf(uint256 tokenId) public view virtual returns (address) {\n        return _requireOwned(tokenId);\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /// @inheritdoc IERC721Metadata\n    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {\n        _requireOwned(tokenId);\n\n        string memory baseURI = _baseURI();\n        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : \"\";\n    }\n\n    /**\n     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n     * by default, can be overridden in child contracts.\n     */\n    function _baseURI() internal view virtual returns (string memory) {\n        return \"\";\n    }\n\n    /// @inheritdoc IERC721\n    function approve(address to, uint256 tokenId) public virtual {\n        _approve(to, tokenId, _msgSender());\n    }\n\n    /// @inheritdoc IERC721\n    function getApproved(uint256 tokenId) public view virtual returns (address) {\n        _requireOwned(tokenId);\n\n        return _getApproved(tokenId);\n    }\n\n    /// @inheritdoc IERC721\n    function setApprovalForAll(address operator, bool approved) public virtual {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /// @inheritdoc IERC721\n    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {\n        return _operatorApprovals[owner][operator];\n    }\n\n    /// @inheritdoc IERC721\n    function transferFrom(address from, address to, uint256 tokenId) public virtual {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        // Setting an \"auth\" arguments enables the `_isAuthorized` check which verifies that the token exists\n        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.\n        address previousOwner = _update(to, tokenId, _msgSender());\n        if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /// @inheritdoc IERC721\n    function safeTransferFrom(address from, address to, uint256 tokenId) public {\n        safeTransferFrom(from, to, tokenId, \"\");\n    }\n\n    /// @inheritdoc IERC721\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {\n        transferFrom(from, to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\n     *\n     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the\n     * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances\n     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by\n     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.\n     */\n    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\n        return _owners[tokenId];\n    }\n\n    /**\n     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.\n     */\n    function _getApproved(uint256 tokenId) internal view virtual returns (address) {\n        return _tokenApprovals[tokenId];\n    }\n\n    /**\n     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in\n     * particular (ignoring whether it is owned by `owner`).\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {\n        return\n            spender != address(0) &&\n            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);\n    }\n\n    /**\n     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.\n     * Reverts if:\n     * - `spender` does not have approval from `owner` for `tokenId`.\n     * - `spender` does not have approval to manage all of `owner`'s assets.\n     *\n     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this\n     * assumption.\n     */\n    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {\n        if (!_isAuthorized(owner, spender, tokenId)) {\n            if (owner == address(0)) {\n                revert ERC721NonexistentToken(tokenId);\n            } else {\n                revert ERC721InsufficientApproval(spender, tokenId);\n            }\n        }\n    }\n\n    /**\n     * @dev Unsafe write access to the balances, used by extensions that \"mint\" tokens using an {ownerOf} override.\n     *\n     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that\n     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.\n     *\n     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the\n     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership\n     * remain consistent with one another.\n     */\n    function _increaseBalance(address account, uint128 value) internal virtual {\n        unchecked {\n            _balances[account] += value;\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner\n     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that\n     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.\n     */\n    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {\n        address from = _ownerOf(tokenId);\n\n        // Perform (optional) operator check\n        if (auth != address(0)) {\n            _checkAuthorized(from, auth, tokenId);\n        }\n\n        // Execute the update\n        if (from != address(0)) {\n            // Clear approval. No need to re-authorize or emit the Approval event\n            _approve(address(0), tokenId, address(0), false);\n\n            unchecked {\n                _balances[from] -= 1;\n            }\n        }\n\n        if (to != address(0)) {\n            unchecked {\n                _balances[to] += 1;\n            }\n        }\n\n        _owners[tokenId] = to;\n\n        emit Transfer(from, to, tokenId);\n\n        return from;\n    }\n\n    /**\n     * @dev Mints `tokenId` and transfers it to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - `to` cannot be the zero address.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _mint(address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner != address(0)) {\n            revert ERC721InvalidSender(address(0));\n        }\n    }\n\n    /**\n     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must not exist.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeMint(address to, uint256 tokenId) internal {\n        _safeMint(to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {\n        _mint(to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data);\n    }\n\n    /**\n     * @dev Destroys `tokenId`.\n     * The approval is cleared when the token is burned.\n     * This is an internal function that does not check if the sender is authorized to operate on the token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _burn(uint256 tokenId) internal {\n        address previousOwner = _update(address(0), tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n    }\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _transfer(address from, address to, uint256 tokenId) internal {\n        if (to == address(0)) {\n            revert ERC721InvalidReceiver(address(0));\n        }\n        address previousOwner = _update(to, tokenId, address(0));\n        if (previousOwner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        } else if (previousOwner != from) {\n            revert ERC721IncorrectOwner(from, tokenId, previousOwner);\n        }\n    }\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients\n     * are aware of the ERC-721 standard to prevent tokens from being forever locked.\n     *\n     * `data` is additional data, it has no specified format and it is sent in call to `to`.\n     *\n     * This internal function is like {safeTransferFrom} in the sense that it invokes\n     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.\n     * implement alternative mechanisms to perform token transfer, such as signature-based.\n     *\n     * Requirements:\n     *\n     * - `tokenId` token must exist and be owned by `from`.\n     * - `to` cannot be the zero address.\n     * - `from` cannot be the zero address.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId) internal {\n        _safeTransfer(from, to, tokenId, \"\");\n    }\n\n    /**\n     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is\n     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\n     */\n    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {\n        _transfer(from, to, tokenId);\n        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data);\n    }\n\n    /**\n     * @dev Approve `to` to operate on `tokenId`\n     *\n     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is\n     * either the owner of the token, or approved to operate on all tokens held by this owner.\n     *\n     * Emits an {Approval} event.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address to, uint256 tokenId, address auth) internal {\n        _approve(to, tokenId, auth, true);\n    }\n\n    /**\n     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not\n     * emitted in the context of transfers.\n     */\n    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {\n        // Avoid reading the owner unless necessary\n        if (emitEvent || auth != address(0)) {\n            address owner = _requireOwned(tokenId);\n\n            // We do not use _isAuthorized because single-token approvals should not be able to call approve\n            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {\n                revert ERC721InvalidApprover(auth);\n            }\n\n            if (emitEvent) {\n                emit Approval(owner, to, tokenId);\n            }\n        }\n\n        _tokenApprovals[tokenId] = to;\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Requirements:\n     * - operator can't be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        if (owner == address(0)) {\n            revert ERC721InvalidApprover(address(0));\n        }\n        if (operator == address(0)) {\n            revert ERC721InvalidOperator(operator);\n        }\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).\n     * Returns the owner.\n     *\n     * Overrides to ownership logic should be done to {_ownerOf}.\n     */\n    function _requireOwned(uint256 tokenId) internal view returns (address) {\n        address owner = _ownerOf(tokenId);\n        if (owner == address(0)) {\n            revert ERC721NonexistentToken(tokenId);\n        }\n        return owner;\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in a uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in a uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev A uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        assembly (\"memory-safe\") {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC-721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n     *   {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)\n\npragma solidity >=0.8.4;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /// @inheritdoc IERC165\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @title ERC-721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC-721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC721/utils/ERC721Utils.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721Receiver} from \"../IERC721Receiver.sol\";\nimport {IERC721Errors} from \"../../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Library that provides common ERC-721 utility functions.\n *\n * See https://eips.ethereum.org/EIPS/eip-721[ERC-721].\n *\n * _Available since v5.1._\n */\nlibrary ERC721Utils {\n    /**\n     * @dev Performs an acceptance check for the provided `operator` by calling {IERC721Receiver-onERC721Received}\n     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).\n     *\n     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).\n     * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept\n     * the transfer.\n     */\n    function checkOnERC721Received(\n        address operator,\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes memory data\n    ) internal {\n        if (to.code.length > 0) {\n            try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) {\n                if (retval != IERC721Receiver.onERC721Received.selector) {\n                    // Token rejected\n                    revert IERC721Errors.ERC721InvalidReceiver(to);\n                }\n            } catch (bytes memory reason) {\n                if (reason.length == 0) {\n                    // non-IERC721Receiver implementer\n                    revert IERC721Errors.ERC721InvalidReceiver(to);\n                } else {\n                    assembly (\"memory-safe\") {\n                        revert(add(reason, 0x20), mload(reason))\n                    }\n                }\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC721} from \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"}},"language":"Solidity","settings":{"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun"}},"stdJsonOutput":{"sources":{"contracts/CogitoAgentsV2.sol":{"id":17},"@openzeppelin/contracts/utils/Bytes.sol":{"id":8},"@openzeppelin/contracts/utils/Panic.sol":{"id":10},"@openzeppelin/contracts/utils/Context.sol":{"id":9},"@openzeppelin/contracts/utils/Strings.sol":{"id":11},"@openzeppelin/contracts/access/Ownable.sol":{"id":0},"@openzeppelin/contracts/utils/math/Math.sol":{"id":14},"@openzeppelin/contracts/access/Ownable2Step.sol":{"id":1},"@openzeppelin/contracts/token/ERC721/ERC721.sol":{"id":3},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"id":15},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"id":4},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"id":16},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":2},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":12},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":13},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"id":5},"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol":{"id":7},"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol":{"id":6}},"contracts":{"contracts/CogitoAgentsV2.sol":{"CogitoAgentsV2":{"abi":[{"type":"constructor","inputs":[{"name":"treasury_","type":"address","internalType":"address payable"},{"name":"maxSupply_","type":"uint256","internalType":"uint256"},{"name":"maxPerWallet_","type":"uint256","internalType":"uint256"},{"name":"maxPerTx_","type":"uint256","internalType":"uint256"},{"name":"reserve_","type":"uint256","internalType":"uint256"},{"name":"price_","type":"uint256","internalType":"uint256"},{"name":"maxPrice_","type":"uint256","internalType":"uint256"},{"name":"base_","type":"string","internalType":"string"},{"name":"contractURI__","type":"string","internalType":"string"}],"stateMutability":"nonpayable"},{"name":"BadConfig","type":"error","inputs":[]},{"name":"BadQty","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":"MetadataIsFrozen","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":"PriceTooHigh","type":"error","inputs":[]},{"name":"SoldOut","type":"error","inputs":[]},{"name":"WalletCap","type":"error","inputs":[]},{"name":"WrongPayment","type":"error","inputs":[]},{"name":"ZeroAddress","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":"BaseURIChanged","type":"event","inputs":[{"name":"newBaseURI","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"BatchMetadataUpdate","type":"event","inputs":[{"name":"_fromTokenId","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_toTokenId","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MetadataFrozen","type":"event","inputs":[{"name":"finalBaseURI","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"Minted","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"firstId","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"qty","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"paid","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferStarted","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"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":"PriceChanged","type":"event","inputs":[{"name":"oldPrice","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newPrice","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"tokenId","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"Withdrawn","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"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":"contractURI","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"costFor","type":"function","inputs":[{"name":"who","type":"address","internalType":"address"},{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"freezeMetadata","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"getApproved","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"hasFreeMint","type":"function","inputs":[{"name":"who","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":"maxPerTx","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"maxPerWallet","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"maxPrice","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"maxSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"metadataFrozen","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"qty","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"payable"},{"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":"ownerOf","type":"function","inputs":[{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pendingOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"price","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"remaining","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"reserve","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"safeTransferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"tokenId","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"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":"b","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPrice","type":"function","inputs":[{"name":"p","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"id","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":"tokenId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","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":"treasury","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address payable"}],"stateMutability":"view"},{"name":"withdraw","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.24+commit.e11b9ed9\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"treasury_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maxSupply_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPerWallet_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPerTx_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"reserve_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"price_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPrice_\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"base_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"contractURI__\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"BadConfig\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"BadQty\",\"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\":\"MetadataIsFrozen\",\"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\":\"PriceTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SoldOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WalletCap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WrongPayment\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"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\":false,\"internalType\":\"string\",\"name\":\"newBaseURI\",\"type\":\"string\"}],\"name\":\"BaseURIChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_fromTokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_toTokenId\",\"type\":\"uint256\"}],\"name\":\"BatchMetadataUpdate\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"finalBaseURI\",\"type\":\"string\"}],\"name\":\"MetadataFrozen\",\"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\":\"qty\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"paid\",\"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\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldPrice\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newPrice\",\"type\":\"uint256\"}],\"name\":\"PriceChanged\",\"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\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdrawn\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"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\":[],\"name\":\"contractURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"who\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"qty\",\"type\":\"uint256\"}],\"name\":\"costFor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"freezeMetadata\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"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\":\"who\",\"type\":\"address\"}],\"name\":\"hasFreeMint\",\"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\":[],\"name\":\"maxPerTx\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxPerWallet\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxPrice\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"metadataFrozen\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"qty\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"payable\",\"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\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"price\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"remaining\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"reserve\",\"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\":\"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\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"b\",\"type\":\"string\"}],\"name\":\"setBaseURI\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"p\",\"type\":\"uint256\"}],\"name\":\"setPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"id\",\"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\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"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\":\"treasury\",\"outputs\":[{\"internalType\":\"address payable\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cogito Agents — https://cogitoagents.pages.dev — X @CogitoAgents\",\"details\":\"Owner powers are ONLY: setPrice (bounded by immutable maxPrice), setBaseURI (until freezeMetadata(), then never),      freezeMetadata, and transfer/renounce ownership (Ownable2Step).      No blacklist, no pause, no transfer restrictions, no owner mint (beyond an optional reserve fixed at deploy; default 0).      No royalties (no ERC-2981). Proceeds accumulate in the contract; withdraw() is callable by anyone and pays ONLY the immutable treasury.\",\"errors\":{\"ERC721IncorrectOwner(address,uint256,address)\":[{\"details\":\"Indicates an error related to the ownership over a particular token. Used in transfers.\",\"params\":{\"owner\":\"Address of the current owner of a token.\",\"sender\":\"Address whose tokens are being transferred.\",\"tokenId\":\"Identifier number of a token.\"}}],\"ERC721InsufficientApproval(address,uint256)\":[{\"details\":\"Indicates a failure with the `operator`’s approval. Used in transfers.\",\"params\":{\"operator\":\"Address that may be allowed to operate on tokens without being their owner.\",\"tokenId\":\"Identifier number of a token.\"}}],\"ERC721InvalidApprover(address)\":[{\"details\":\"Indicates a failure with the `approver` of a token to be approved. Used in approvals.\",\"params\":{\"approver\":\"Address initiating an approval operation.\"}}],\"ERC721InvalidOperator(address)\":[{\"details\":\"Indicates a failure with the `operator` to be approved. Used in approvals.\",\"params\":{\"operator\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"ERC721InvalidOwner(address)\":[{\"details\":\"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. Used in balance queries.\",\"params\":{\"owner\":\"Address of the current owner of a token.\"}}],\"ERC721InvalidReceiver(address)\":[{\"details\":\"Indicates a failure with the token `receiver`. Used in transfers.\",\"params\":{\"receiver\":\"Address to which tokens are being transferred.\"}}],\"ERC721InvalidSender(address)\":[{\"details\":\"Indicates a failure with the token `sender`. Used in transfers.\",\"params\":{\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC721NonexistentToken(uint256)\":[{\"details\":\"Indicates a `tokenId` whose `owner` is the zero address.\",\"params\":{\"tokenId\":\"Identifier number of a token.\"}}],\"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.\"}]},\"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.\"},\"BatchMetadataUpdate(uint256,uint256)\":{\"details\":\"EIP-4906\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `tokenId` token is transferred from `from` to `to`.\"}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"approve(address,uint256)\":{\"details\":\"Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.\"},\"balanceOf(address)\":{\"details\":\"Returns the number of tokens in ``owner``'s account.\"},\"costFor(address,uint256)\":{\"params\":{\"who\":\"Minting address. @param qty Number of NFTs.\"}},\"getApproved(uint256)\":{\"details\":\"Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.\"},\"isApprovedForAll(address,address)\":{\"details\":\"Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}\"},\"mint(uint256)\":{\"details\":\"msg.value must EQUAL costFor(msg.sender, qty): price()*(qty-1) if the sender has never minted, else price()*qty.      Reverts: BadQty (0 or > maxPerTx), SoldOut, WalletCap (> maxPerWallet total), WrongPayment (any other value).      Free first mint example: mint(1) with value 0 — calldata 0xa0712d68 + uint256(1).\",\"params\":{\"qty\":\"Number of NFTs (1..maxPerTx).\"}},\"name()\":{\"details\":\"Returns the token collection name.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"ownerOf(uint256)\":{\"details\":\"Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"safeTransferFrom(address,address,uint256)\":{\"details\":\"Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or   {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event.\"},\"safeTransferFrom(address,address,uint256,bytes)\":{\"details\":\"Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event.\"},\"setApprovalForAll(address,bool)\":{\"details\":\"Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the address zero. Emits an {ApprovalForAll} event.\"},\"supportsInterface(bytes4)\":{\"details\":\"ERC-165 incl. EIP-4906 (0x49064906).\"},\"symbol()\":{\"details\":\"Returns the token collection symbol.\"},\"tokenURI(uint256)\":{\"details\":\"Returns the Uniform Resource Identifier (URI) for `tokenId` token.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.\"},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.\"}},\"title\":\"Cogito Agents (COG-A) — AI-agent-first NFT on BNB Chain\",\"version\":1},\"userdoc\":{\"events\":{\"Minted(address,uint256,uint256,uint256)\":{\"notice\":\"Emitted on every mint. paid == wei paid (0 for a free first mint).\"}},\"kind\":\"user\",\"methods\":{\"contractURI()\":{\"notice\":\"Collection-level metadata (name, description, image, external_link) for marketplaces/indexers. Fixed at deploy.\"},\"costFor(address,uint256)\":{\"notice\":\"Exact wei `who` must send to mint `qty` right now (includes the free first NFT). Returns 0 for qty 0.\"},\"freezeMetadata()\":{\"notice\":\"Permanently locks the base URI. Irreversible.\"},\"hasFreeMint(address)\":{\"notice\":\"True if `who` has never minted, i.e. its next NFT is free.\"},\"maxPerTx()\":{\"notice\":\"Max NFTs per mint() call.\"},\"maxPerWallet()\":{\"notice\":\"Max NFTs any single address can mint over its lifetime.\"},\"maxPrice()\":{\"notice\":\"Ceiling for price(); setPrice can never exceed it.\"},\"maxSupply()\":{\"notice\":\"Hard cap on total NFTs.\"},\"metadataFrozen()\":{\"notice\":\"True once freezeMetadata() was called; baseURI can never change afterwards.\"},\"mint(uint256)\":{\"notice\":\"Mint `qty` NFTs to msg.sender.\"},\"mintedBy(address)\":{\"notice\":\"NFTs minted by each address (0 => its next NFT is free).\"},\"price()\":{\"notice\":\"Current price in wei for each NFT after a wallet's free first one.\"},\"remaining()\":{\"notice\":\"NFTs still mintable before sold out.\"},\"reserve()\":{\"notice\":\"NFTs minted to the deployer at deploy (ids 1..reserve). Default deploy uses 0.\"},\"setBaseURI(string)\":{\"notice\":\"Owner may change the metadata base URI until freezeMetadata() is called.\"},\"setPrice(uint256)\":{\"notice\":\"Owner may adjust the price to track ~US$0.50 as BNB moves. Can never exceed immutable maxPrice.\"},\"totalSupply()\":{\"notice\":\"NFTs minted so far (token ids are 1..totalSupply).\"},\"treasury()\":{\"notice\":\"The only address withdraw() can pay.\"},\"withdraw()\":{\"notice\":\"Anyone may call; the full balance goes only to the immutable treasury.\"}},\"notice\":\"HOW TO MINT (agents): 1) v = costFor(you, qty)  2) mint(qty) with msg.value == v exactly.         Each wallet's FIRST NFT is free (gas only); every further NFT costs price() wei. Max maxPerWallet() per wallet.         Machine-readable docs: https://cogitoagents.pages.dev/llms.txt and /mint.json\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/CogitoAgentsV2.sol\":\"CogitoAgentsV2\"},\"evmVersion\":\"cancun\",\"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/access/Ownable2Step.sol\":{\"keccak256\":\"0xdcad8898fda432696597752e8ec361b87d85c82cb258115427af006dacf7128c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e2c9d517f0c136d54bd00cd57959d25681d4d6273f5bbbc263afe228303772f0\",\"dweb:/ipfs/QmReNFjXBiufByiAAzfSQ2SM5r3qeUErn46BmN3yVRvrek\"]},\"@openzeppelin/contracts/interfaces/draft-IERC6093.sol\":{\"keccak256\":\"0x1b88b3fb3d85ba5496d7d5f396f83ee1fddcdd6762059ff65992655b67920998\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://89393bb3212da1c0889601b9706a07b39419ddc4d2faab9eaf6e7f9152cf6a1c\",\"dweb:/ipfs/QmcCfzzxv1Bkdz1c1yF4gQCeYb6Us5BJANnzTFqawfd1HL\"]},\"@openzeppelin/contracts/token/ERC721/ERC721.sol\":{\"keccak256\":\"0xf6bb0dc431a9c50e25756412ec14cfcd4dc61dd40b8dc0e1b58ec09fce6d5564\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://eb87fef7e8ed754b8600cd5d42e4f23128059006368ffd19e4d50cc166471ee5\",\"dweb:/ipfs/Qmc1vy1cevKreGUsG7S79gyhNvDtPnNz9qG47eYVHmMKLs\"]},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"keccak256\":\"0xf78f05f3b8c9f75570e85300d7b4600d7f6f6a198449273f31d44c1641adb46f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e28b872613b45e0e801d4995aa4380be2531147bfe2d85c1d6275f1de514fba3\",\"dweb:/ipfs/QmeeFcfShHYaS3BdgVj78nxR28ZaVUwbvr66ud8bT6kzw9\"]},\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\":{\"keccak256\":\"0x88cd5e3bee2e8c36b8d9058fbcaa81ad5704281b25634122234b55ea853d8055\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8dc7e7ab5b8ea36c15027ab04221b05d1c970f47a53e9fd47ead8ca665d49c7e\",\"dweb:/ipfs/Qmeeph7fsDyfRr8vb2L8KcDEmKPb224TAayMvgqgGAnqpL\"]},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"keccak256\":\"0xf46268c37522320bb2119a5a394bc5c739a95c0c574c8d08e8c643f4d06e5c76\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://517e4b295f35b9947c72ad7379a6089439ece7bb6f4a2ea0a159da13046c039e\",\"dweb:/ipfs/QmZXzkSfLUbvujig3zVbpDHykpHhqLpvQtdiN3B5j4TA3u\"]},\"@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol\":{\"keccak256\":\"0xc7efbc23214ad7dced8bf2249460f4bda114d57f6a0079f84040654280f455bd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1f5bd44efca8c8c0d74439e7b808d1f9c4af1df78f91fef8e8bbca8104645435\",\"dweb:/ipfs/Qmb42XSd8MKsEitp42sZkSFGqDRigk6QgGXtiJyJqUZJJ6\"]},\"@openzeppelin/contracts/utils/Bytes.sol\":{\"keccak256\":\"0xf80e4b96b6849936ea0fabd76cf81b13d7276295fddb1e1c07afb3ddf650b0ac\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6430007255ac11c6e9c4331a418f3af52ff66fbbae959f645301d025b20aeb08\",\"dweb:/ipfs/QmQE5fjmBBRw9ndnzJuC2uskYss1gbaR7JdazoCf1FGoBj\"]},\"@openzeppelin/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"@openzeppelin/contracts/utils/Panic.sol\":{\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a\",\"dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG\"]},\"@openzeppelin/contracts/utils/Strings.sol\":{\"keccak256\":\"0x1fdc2de9585ab0f1c417f02a873a2b6343cd64bb7ffec6b00ffa11a4a158d9e8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1ab223a3d969c6cd7610049431dd42740960c477e45878f5d8b54411f7a32bdc\",\"dweb:/ipfs/QmWumhjvhpKcwx3vDPQninsNVTc3BGvqaihkQakFkQYpaS\"]},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"keccak256\":\"0x2d9dc2fe26180f74c11c13663647d38e259e45f95eb88f57b61d2160b0109d3e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://81233d1f98060113d9922180bb0f14f8335856fe9f339134b09335e9f678c377\",\"dweb:/ipfs/QmWh6R35SarhAn4z2wH8SU456jJSYL2FgucfTFgbHJJN4E\"]},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617\",\"dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u\"]},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"keccak256\":\"0x59973a93b1f983f94e10529f46ca46544a9fec2b5f56fb1390bbe9e0dc79f857\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c55ef8f0b9719790c2ae6f81d80a59ffb89f2f0abe6bc065585bd79edce058c5\",\"dweb:/ipfs/QmNNmCbX9NjPXKqHJN8R1WC2rNeZSQrPZLd6FF6AKLyH5Y\"]},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"keccak256\":\"0xc8cae21c9ae4a46e5162ff9bf5b351d6fa6a6eba72d515f3bc1bdfeda7fdf083\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ce830ebcf28e31643caba318996db3763c36d52cd0f23798ba83c135355d45e9\",\"dweb:/ipfs/QmdGPcvptHN7UBCbUYBbRX3hiRVRFLRwno8b4uga6uFNif\"]},\"@openzeppelin/contracts/utils/math/SignedMath.sol\":{\"keccak256\":\"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://db5fbb3dddd8b7047465b62575d96231ba8a2774d37fb4737fbf23340fabbb03\",\"dweb:/ipfs/QmVUSvooZKEdEdap619tcJjTLcAuH6QBdZqAzWwnAXZAWJ\"]},\"contracts/CogitoAgentsV2.sol\":{\"keccak256\":\"0x8639d1cb86eadd96ca29ef90e023f0519089a7aea9219a2c1423acc6ebcdce51\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ba011d3bfcd087d4e9040be126893ed16ca37a2427a9ec94ff7b7b573ab8ce2a\",\"dweb:/ipfs/QmTsVxacGFZ4gqDkfJQDJENkfaGEQa7oesYT13h7bg4KWa\"]}},\"version\":1}","userdoc":{"kind":"user","events":{"Minted(address,uint256,uint256,uint256)":{"notice":"Emitted on every mint. paid == wei paid (0 for a free first mint)."}},"notice":"HOW TO MINT (agents): 1) v = costFor(you, qty)  2) mint(qty) with msg.value == v exactly.         Each wallet's FIRST NFT is free (gas only); every further NFT costs price() wei. Max maxPerWallet() per wallet.         Machine-readable docs: https://cogitoagents.pages.dev/llms.txt and /mint.json","methods":{"price()":{"notice":"Current price in wei for each NFT after a wallet's free first one."},"reserve()":{"notice":"NFTs minted to the deployer at deploy (ids 1..reserve). Default deploy uses 0."},"maxPerTx()":{"notice":"Max NFTs per mint() call."},"maxPrice()":{"notice":"Ceiling for price(); setPrice can never exceed it."},"treasury()":{"notice":"The only address withdraw() can pay."},"withdraw()":{"notice":"Anyone may call; the full balance goes only to the immutable treasury."},"maxSupply()":{"notice":"Hard cap on total NFTs."},"remaining()":{"notice":"NFTs still mintable before sold out."},"contractURI()":{"notice":"Collection-level metadata (name, description, image, external_link) for marketplaces/indexers. Fixed at deploy."},"mint(uint256)":{"notice":"Mint `qty` NFTs to msg.sender."},"totalSupply()":{"notice":"NFTs minted so far (token ids are 1..totalSupply)."},"maxPerWallet()":{"notice":"Max NFTs any single address can mint over its lifetime."},"freezeMetadata()":{"notice":"Permanently locks the base URI. Irreversible."},"metadataFrozen()":{"notice":"True once freezeMetadata() was called; baseURI can never change afterwards."},"mintedBy(address)":{"notice":"NFTs minted by each address (0 => its next NFT is free)."},"setPrice(uint256)":{"notice":"Owner may adjust the price to track ~US$0.50 as BNB moves. Can never exceed immutable maxPrice."},"setBaseURI(string)":{"notice":"Owner may change the metadata base URI until freezeMetadata() is called."},"hasFreeMint(address)":{"notice":"True if `who` has never minted, i.e. its next NFT is free."},"costFor(address,uint256)":{"notice":"Exact wei `who` must send to mint `qty` right now (includes the free first NFT). Returns 0 for qty 0."}},"version":1},"devdoc":{"kind":"dev","title":"Cogito Agents (COG-A) — AI-agent-first NFT on BNB Chain","author":"Cogito Agents — https://cogitoagents.pages.dev — X @CogitoAgents","errors":{"ERC721InvalidOwner(address)":[{"params":{"owner":"Address of the current owner of a token."},"details":"Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721. Used in balance queries."}],"ERC721InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"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."}],"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."},"BatchMetadataUpdate(uint256,uint256)":{"details":"EIP-4906"}},"details":"Owner powers are ONLY: setPrice (bounded by immutable maxPrice), setBaseURI (until freezeMetadata(), then never),      freezeMetadata, and transfer/renounce ownership (Ownable2Step).      No blacklist, no pause, no transfer restrictions, no owner mint (beyond an optional reserve fixed at deploy; default 0).      No royalties (no ERC-2981). Proceeds accumulate in the contract; withdraw() is callable by anyone and pays ONLY the immutable treasury.","methods":{"name()":{"details":"Returns the token collection name."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the token collection symbol."},"mint(uint256)":{"params":{"qty":"Number of NFTs (1..maxPerTx)."},"details":"msg.value must EQUAL costFor(msg.sender, qty): price()*(qty-1) if the sender has never minted, else price()*qty.      Reverts: BadQty (0 or > maxPerTx), SoldOut, WalletCap (> maxPerWallet total), WrongPayment (any other value).      Free first mint example: mint(1) with value 0 — calldata 0xa0712d68 + uint256(1)."},"pendingOwner()":{"details":"Returns the address of the pending owner."},"ownerOf(uint256)":{"details":"Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"tokenURI(uint256)":{"details":"Returns the Uniform Resource Identifier (URI) for `tokenId` token."},"balanceOf(address)":{"details":"Returns the number of tokens in ``owner``'s account."},"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":"Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist."},"approve(address,uint256)":{"details":"Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event."},"costFor(address,uint256)":{"params":{"who":"Minting address. @param qty Number of NFTs."}},"supportsInterface(bytes4)":{"details":"ERC-165 incl. EIP-4906 (0x49064906)."},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer."},"setApprovalForAll(address,bool)":{"details":"Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the address zero. Emits an {ApprovalForAll} event."},"isApprovedForAll(address,address)":{"details":"Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}"},"transferFrom(address,address,uint256)":{"details":"Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256)":{"details":"Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or   {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."},"safeTransferFrom(address,address,uint256,bytes)":{"details":"Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon   a safe transfer. Emits a {Transfer} event."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_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":403,"label":"_name","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"1","type":"t_string_storage","astId":405,"label":"_symbol","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"2","type":"t_mapping(t_uint256,t_address)","astId":409,"label":"_owners","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"3","type":"t_mapping(t_address,t_uint256)","astId":413,"label":"_balances","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"4","type":"t_mapping(t_uint256,t_address)","astId":417,"label":"_tokenApprovals","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"5","type":"t_mapping(t_address,t_mapping(t_address,t_bool))","astId":423,"label":"_operatorApprovals","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"6","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"7","type":"t_address","astId":156,"label":"_pendingOwner","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"8","type":"t_uint256","astId":7610,"label":"price","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"9","type":"t_uint256","astId":7613,"label":"totalSupply","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"10","type":"t_mapping(t_address,t_uint256)","astId":7618,"label":"mintedBy","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"11","type":"t_string_storage","astId":7620,"label":"baseURI_","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"12","type":"t_bool","astId":7623,"label":"metadataFrozen","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"},{"slot":"13","type":"t_string_storage","astId":7625,"label":"contractURI_","offset":0,"contract":"contracts/CogitoAgentsV2.sol:CogitoAgentsV2"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"1155:6329:17:-:0;;;3007:870;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3274:10;1380:113:3;;;;;;;;;;;;;-1:-1:-1;;;1380:113:3;;;;;;;;;;;;;;;;-1:-1:-1;;;1380:113:3;;;1454:5;1446;:13;;;;;;:::i;:::-;-1:-1:-1;1469:7:3;:17;1479:7;1469;:17;:::i;:::-;-1:-1:-1;;;;;;;;1273:26:0;;1269:95;;1322:31;;-1:-1:-1;;;1322:31:0;;1350:1;1322:31;;;4810:51:18;4783:18;;1322:31:0;;;;;;;;1269:95;1373:32;1392:12;1373:18;:32::i;:::-;-1:-1:-1;;;;;;3300:23:17;::::2;3296:49;;3332:13;;-1:-1:-1::0;;;3332:13:17::2;;;;;;;;;;;3296:49;3359:15:::0;;;:40:::2;;;3389:10;3378:8;:21;3359:40;:62;;;-1:-1:-1::0;3403:18:17;;3359:62:::2;:80;;;-1:-1:-1::0;3425:14:17;;3359:80:::2;:102;;;;3452:9;3443:6;:18;3359:102;3355:126;;;3470:11;;-1:-1:-1::0;;;3470:11:17::2;;;;;;;;;;;3355:126;-1:-1:-1::0;;;;;3491:20:17;::::2;;::::0;3513:22:::2;::::0;;;-1:-1:-1;3537:28:17;;;3567:20:::2;::::0;;;3597:18:::2;::::0;;;3617:5:::2;:14:::0;;;3633:20:::2;::::0;;;3655:8:::2;:16;3666:5:::0;3655:8;:16:::2;:::i;:::-;-1:-1:-1::0;3673:12:17::2;:28;3688:13:::0;3673:12;:28:::2;:::i;:::-;-1:-1:-1::0;3728:1:17::2;3711:60;3736:8;3731:1;:13;3711:60;;3751:20;3757:10;3769:1:::0;3751:5:::2;:20::i;:::-;3746:3:::0;::::2;::::0;::::2;:::i;:::-;;;;3711:60;;;-1:-1:-1::0;3781:11:17::2;:22:::0;;;3817:12;;3813:57:::2;;3836:34;::::0;;3855:1:::2;5327:25:18::0;;5383:2;5368:18;;5361:34;;;-1:-1:-1;5411:18:18;;;5404:34;3836::17;;3843:10:::2;::::0;3836:34:::2;::::0;;;;;5315:2:18;3836:34:17;;::::2;3813:57;3007:870:::0;;;;;;;;;1155:6329;;2011:153:1;2100:13;2093:20;;-1:-1:-1;;;;;;2093:20:1;;;2123:34;2148:8;2123:24;:34::i;:::-;2011:153;:::o;9624:327:3:-;-1:-1:-1;;;;;9691:16:3;;9687:87;;9730:33;;-1:-1:-1;;;9730:33:3;;9760:1;9730:33;;;4810:51:18;4783:18;;9730:33:3;4664:203:18;9687:87:3;9783:21;9807:32;9815:2;9819:7;9783:21;9807:7;:32::i;:::-;9783:56;-1:-1:-1;;;;;;9853:27:3;;;9849:96;;9903:31;;-1:-1:-1;;;9903:31:3;;9931:1;9903:31;;;4810:51:18;4783:18;;9903:31:3;4664:203:18;9849:96:3;9677:274;9624:327;;:::o;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;8507:795:3:-;8593:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:3;;;;8704:18;;;8700:86;;8738:37;8755:4;8761;8767:7;8738:16;:37::i;:::-;-1:-1:-1;;;;;8830:18:3;;;8826:256;;8946:48;8963:1;8967:7;8963:1;;8946:8;:48::i;:::-;-1:-1:-1;;;;;9037:15:3;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9037:20:3;;;8826:256;-1:-1:-1;;;;;9096:16:3;;;9092:107;;-1:-1:-1;;;;;9156:13:3;;;;;;:9;:13;;;;;:18;;9173:1;9156:18;;;9092:107;9209:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9209:21:3;-1:-1:-1;;;;;9209:21:3;;;;;;;;;9246:27;;9209:16;;9246:27;;;;;;;9291:4;8507:795;-1:-1:-1;;;;8507:795:3:o;6751:368::-;6863:38;6877:5;6884:7;6893;6863:13;:38::i;:::-;6858:255;;-1:-1:-1;;;;;6921:19:3;;6917:186;;6967:31;;-1:-1:-1;;;6967:31:3;;;;;5595:25:18;;;5568:18;;6967:31:3;5449:177:18;6917:186:3;7044:44;;-1:-1:-1;;;7044:44:3;;-1:-1:-1;;;;;5823:32:18;;7044:44:3;;;5805:51:18;5872:18;;;5865:34;;;5778:18;;7044:44:3;5631:274:18;14440:662:3;14600:9;:31;;;-1:-1:-1;;;;;;14613:18:3;;;;14600:31;14596:460;;;14647:13;14663:22;14677:7;14663:13;:22::i;:::-;14647:38;-1:-1:-1;;;;;;14813:18:3;;;;;;:35;;;14844:4;-1:-1:-1;;;;;14835:13:3;:5;-1:-1:-1;;;;;14835:13:3;;;14813:35;:69;;;;-1:-1:-1;;;;;;3776:25:3;;;3753:4;3776:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;14852:30;14813:69;14809:142;;;14909:27;;-1:-1:-1;;;14909:27:3;;-1:-1:-1;;;;;4828:32:18;;14909:27:3;;;4810:51:18;4783:18;;14909:27:3;4664:203:18;14809:142:3;14969:9;14965:81;;;15023:7;15019:2;-1:-1:-1;;;;;15003:28:3;15012:5;-1:-1:-1;;;;;15003:28:3;;;;;;;;;;;14965:81;14633:423;14596:460;-1:-1:-1;;15066:24:3;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15066:29:3;-1:-1:-1;;;;;15066:29:3;;;;;;;;;;14440:662::o;6047:272::-;6150:4;-1:-1:-1;;;;;6185:21:3;;;;;;:127;;;6232:7;-1:-1:-1;;;;;6223:16:3;:5;-1:-1:-1;;;;;6223:16:3;;:52;;;-1:-1:-1;;;;;;3776:25:3;;;3753:4;3776:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;6243:32;6223:88;;;-1:-1:-1;5679:7:3;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6279:32:3;;;5705:24;;6279:32;6223:88;6166:146;6047:272;-1:-1:-1;;;;6047:272:3:o;15957:241::-;16020:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:3;;16082:88;;16128:31;;-1:-1:-1;;;16128:31:3;;;;;5595:25:18;;;5568:18;;16128:31:3;5449:177:18;16082:88:3;16186:5;15957:241;-1:-1:-1;;15957:241:3:o;14:127:18:-;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:18;;;353:36;;;369:18;;:::i;:::-;444:2;438:9;412:2;498:13;;-1:-1:-1;;494:22:18;;;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:1109::-;1165:6;1173;1181;1189;1197;1205;1213;1221;1229;1282:3;1270:9;1261:7;1257:23;1253:33;1250:53;;;1299:1;1296;1289:12;1250:53;1325:16;;-1:-1:-1;;;;;1370:31:18;;1360:42;;1350:70;;1416:1;1413;1406:12;1350:70;1439:5;1429:15;;;1484:2;1473:9;1469:18;1463:25;1453:35;;1528:2;1517:9;1513:18;1507:25;1497:35;;1572:2;1561:9;1557:18;1551:25;1541:35;;1616:3;1605:9;1601:19;1595:26;1585:36;;1661:3;1650:9;1646:19;1640:26;1630:36;;1706:3;1695:9;1691:19;1685:26;1675:36;;1755:3;1744:9;1740:19;1734:26;1795:1;1791;1787:2;1783:10;1779:18;1820:2;1812:6;1809:14;1806:34;;;1836:1;1833;1826:12;1806:34;1859:61;1912:7;1903:6;1892:9;1888:22;1859:61;:::i;:::-;1849:71;;1966:3;1955:9;1951:19;1945:26;1929:42;;1996:2;1986:8;1983:16;1980:36;;;2012:1;2009;2002:12;1980:36;;2035:63;2090:7;2079:8;2068:9;2064:24;2035:63;:::i;:::-;2025:73;;;995:1109;;;;;;;;;;;:::o;2109:380::-;2188:1;2184:12;;;;2231;;;2252:61;;2306:4;2298:6;2294:17;2284:27;;2252:61;2359:2;2351:6;2348:14;2328:18;2325:38;2322:161;;2405:10;2400:3;2396:20;2393:1;2386:31;2440:4;2437:1;2430:15;2468:4;2465:1;2458:15;2322:161;;2109:380;;;:::o;2620:518::-;2722:2;2717:3;2714:11;2711:421;;;2758:5;2755:1;2748:16;2802:4;2799:1;2789:18;2872:2;2860:10;2856:19;2853:1;2849:27;2843:4;2839:38;2908:4;2896:10;2893:20;2890:47;;;-1:-1:-1;2931:4:18;2890:47;2986:2;2981:3;2977:12;2974:1;2970:20;2964:4;2960:31;2950:41;;3041:81;3059:2;3052:5;3049:13;3041:81;;;3118:1;3104:16;;3085:1;3074:13;3041:81;;;3045:3;;2620:518;;;:::o;3314:1345::-;3434:10;;-1:-1:-1;;;;;3456:30:18;;3453:56;;;3489:18;;:::i;:::-;3518:97;3608:6;3568:38;3600:4;3594:11;3568:38;:::i;:::-;3562:4;3518:97;:::i;:::-;3670:4;;3727:2;3716:14;;3744:1;3739:663;;;;4446:1;4463:6;4460:89;;;-1:-1:-1;4515:19:18;;;4509:26;4460:89;-1:-1:-1;;3271:1:18;3267:11;;;3263:24;3259:29;3249:40;3295:1;3291:11;;;3246:57;4562:81;;3709:944;;3739:663;2567:1;2560:14;;;2604:4;2591:18;;-1:-1:-1;;3775:20:18;;;3893:236;3907:7;3904:1;3901:14;3893:236;;;3996:19;;;3990:26;3975:42;;4088:27;;;;4056:1;4044:14;;;;3923:19;;3893:236;;;3897:3;4157:6;4148:7;4145:19;4142:201;;;4218:19;;;4212:26;-1:-1:-1;;4301:1:18;4297:14;;;4313:3;4293:24;4289:37;4285:42;4270:58;4255:74;;4142:201;;;4389:1;4380:6;4377:1;4373:14;4369:22;4363:4;4356:36;3709:944;;;;;3314:1345;;:::o;4872:232::-;4911:3;4932:17;;;4929:140;;4991:10;4986:3;4982:20;4979:1;4972:31;5026:4;5023:1;5016:15;5054:4;5051:1;5044:15;4929:140;-1:-1:-1;5096:1:18;5085:13;;4872:232::o;5631:274::-;1155:6329:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1155:6329:17:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7236:153;;;;;;;;;;-1:-1:-1;7236:153:17;;;;;:::i;:::-;;:::i;:::-;;;565:14:18;;558:22;540:41;;528:2;513:18;7236:153:17;;;;;;;;2263:89:3;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3299:154::-;;;;;;;;;;-1:-1:-1;3299:154:3;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:18;;;1679:51;;1667:2;1652:18;3299:154:3;1533:203:18;3152:113:3;;;;;;;;;;-1:-1:-1;3152:113:3;;;;;:::i;:::-;;:::i;:::-;;2001:26:17;;;;;;;;;;;;;;;;;;;2324:25:18;;;2312:2;2297:18;2001:26:17;2178:177:18;3852:578:3;;;;;;;;;;-1:-1:-1;3852:578:3;;;;;:::i;:::-;;:::i;6375:213:17:-;;;;;;;;;;;;;:::i;2106:43::-;;;;;;;;;;-1:-1:-1;2106:43:17;;;;;:::i;:::-;;;;;;;;;;;;;;4464:132:3;;;;;;;;;;-1:-1:-1;4464:132:3;;;;;:::i;:::-;;:::i;1361:37:17:-;;;;;;;;;;;;;;;5697:88;;;;;;;;;;;;;:::i;6683:252::-;;;;;;;;;;-1:-1:-1;6683:252:17;;;;;:::i;:::-;;:::i;1777:41::-;;;;;;;;;;;;;;;2103:118:3;;;;;;;;;;-1:-1:-1;2103:118:3;;;;;:::i;:::-;;:::i;1861:208::-;;;;;;;;;;-1:-1:-1;1861:208:3;;;;;:::i;:::-;;:::i;2293:101:0:-;;;;;;;;;;;;;:::i;2244:229:1:-;;;;;;;;;;;;;:::i;1638:85:0:-;;;;;;;;;;-1:-1:-1;1710:6:0;;-1:-1:-1;;;;;1710:6:0;1638:85;;6122:160:17;;;;;;;;;;-1:-1:-1;6122:160:17;;;;;:::i;:::-;;:::i;2394:93:3:-;;;;;;;;;;;;;:::i;1908:20:17:-;;;;;;;;;;;;;;;;4325:624;;;;;;:::i;:::-;;:::i;3487:144:3:-;;;;;;;;;;-1:-1:-1;3487:144:3;;;;;:::i;:::-;;:::i;4630:233::-;;;;;;;;;;-1:-1:-1;4630:233:3;;;;;:::i;:::-;;:::i;2529:255::-;;;;;;;;;;-1:-1:-1;2529:255:3;;;;;:::i;:::-;;:::i;1580:32:17:-;;;;;;;;;;;;;;;7003:177;;;;;;;;;;;;;:::i;1249:34::-;;;;;;;;;;;;;;;5545:93;;;;;;;;;;-1:-1:-1;5545:93:17;;;;;:::i;:::-;-1:-1:-1;;;;;5617:13:17;5602:4;5617:13;;;:8;:13;;;;;;:18;;5545:93;1232:99:1;;;;;;;;;;-1:-1:-1;1311:13:1;;-1:-1:-1;;;;;1311:13:1;1232:99;;1685:33:17;;;;;;;;;;;;;;;5919:85;;;;;;;;;;;;;:::i;3665:153:3:-;;;;;;;;;;-1:-1:-1;3665:153:3;;;;;:::i;:::-;;:::i;1649:178:1:-;;;;;;;;;;-1:-1:-1;1649:178:1;;;;;:::i;:::-;;:::i;5308:156:17:-;;;;;;;;;;-1:-1:-1;5308:156:17;;;;;:::i;:::-;;:::i;1446:33::-;;;;;;;;;;;;;;;2276:26;;;;;;;;;;-1:-1:-1;2276:26:17;;;;;;;;7236:153;7304:4;-1:-1:-1;;;;;;7327:24:17;;-1:-1:-1;;;7327:24:17;;:55;;;7355:27;7379:2;7355:23;:27::i;:::-;7320:62;7236:153;-1:-1:-1;;7236:153:17:o;2263:89:3:-;2308:13;2340:5;2333:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2263:89;:::o;3299:154::-;3366:7;3385:22;3399:7;3385:13;:22::i;:::-;-1:-1:-1;5679:7:3;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;5705:24:3;3425:21;5609:127;3152:113;3223:35;3232:2;3236:7;735:10:9;3223:8:3;:35::i;:::-;3152:113;;:::o;3852:578::-;-1:-1:-1;;;;;3946:16:3;;3942:87;;3985:33;;-1:-1:-1;;;3985:33:3;;4015:1;3985:33;;;1679:51:18;1652:18;;3985:33:3;;;;;;;;3942:87;4247:21;4271:34;4279:2;4283:7;735:10:9;4271:7:3;:34::i;:::-;4247:58;;4336:4;-1:-1:-1;;;;;4319:21:3;:13;-1:-1:-1;;;;;4319:21:3;;4315:109;;4363:50;;-1:-1:-1;;;4363:50:3;;-1:-1:-1;;;;;6240:15:18;;;4363:50:3;;;6222:34:18;6272:18;;;6265:34;;;6335:15;;6315:18;;;6308:43;6157:18;;4363:50:3;5982:375:18;4315:109:3;3932:498;3852:578;;;:::o;6375:213:17:-;6473:29;;6428:21;;6414:11;;-1:-1:-1;;;;;6473:8:17;:13;;6428:21;;6414:11;6473:29;6414:11;6473:29;6428:21;6473:13;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6459:43;;;6520:2;6512:30;;;;-1:-1:-1;;;6512:30:17;;6774:2:18;6512:30:17;;;6756:21:18;6813:2;6793:18;;;6786:30;-1:-1:-1;;;6832:18:18;;;6825:45;6887:18;;6512:30:17;6572:339:18;6512:30:17;6567:8;-1:-1:-1;;;;;6557:24:17;;6577:3;6557:24;;;;2324:25:18;;2312:2;2297:18;;2178:177;6557:24:17;;;;;;;;6404:184;;6375:213::o;4464:132:3:-;4550:39;4567:4;4573:2;4577:7;4550:39;;;;;;;;;;;;:16;:39::i;:::-;4464:132;;;:::o;5697:88:17:-;5741:7;5771:11;;5759:9;:23;;;;:::i;:::-;5752:30;;5697:88;:::o;6683:252::-;1531:13:0;:11;:13::i;:::-;6755:14:17::1;::::0;::::1;;6751:45;;;6778:18;;-1:-1:-1::0;;;6778:18:17::1;;;;;;;;;;;6751:45;6806:8;:12;6817:1:::0;;6806:8;:12:::1;:::i;:::-;;6833:17;6848:1;;6833:17;;;;;;;:::i;:::-;;;;;;;;6865:33;::::0;;6885:1:::1;9781:25:18::0;;6888:9:17::1;9837:2:18::0;9822:18;;9815:34;6865:33:17::1;::::0;9754:18:18;6865:33:17::1;;;;;;;6683:252:::0;;:::o;2103:118:3:-;2166:7;2192:22;2206:7;2192:13;:22::i;1861:208::-;1924:7;-1:-1:-1;;;;;1947:19:3;;1943:87;;1989:30;;-1:-1:-1;;;1989:30:3;;2016:1;1989:30;;;1679:51:18;1652:18;;1989:30:3;1533:203:18;1943:87:3;-1:-1:-1;;;;;;2046:16:3;;;;;:9;:16;;;;;;;1861:208::o;2293:101:0:-;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;2244:229:1:-;1311:13;;735:10:9;;-1:-1:-1;;;;;1311:13:1;2339:24;;2335:96;;2386:34;;-1:-1:-1;;;2386:34:1;;-1:-1:-1;;;;;1697:32:18;;2386:34:1;;;1679:51:18;1652:18;;2386:34:1;1533:203:18;2335:96:1;2440:26;2459:6;2440:18;:26::i;:::-;2286:187;2244:229::o;6122:160:17:-;1531:13:0;:11;:13::i;:::-;6188:8:17::1;6184:1;:12;6180:39;;;6205:14;;-1:-1:-1::0;;;6205:14:17::1;;;;;;;;;;;6180:39;6247:5;::::0;6234:22:::1;::::0;;9781:25:18;;;9837:2;9822:18;;9815:34;;;6234:22:17::1;::::0;9754:18:18;6234:22:17::1;;;;;;;6266:5;:9:::0;6122:160::o;2394:93:3:-;2441:13;2473:7;2466:14;;;;;:::i;4325:624:17:-;4383:8;;;:26;;;4401:8;4395:3;:14;4383:26;4379:47;;;4418:8;;-1:-1:-1;;;4418:8:17;;;;;;;;;;;4379:47;4448:11;;4483:9;4473:7;4477:3;4448:11;4473:7;:::i;:::-;:19;4469:41;;;4501:9;;-1:-1:-1;;;4501:9:17;;;;;;;;;;;4469:41;4544:10;4520:12;4535:20;;;:8;:20;;;;;;;4577:10;4584:3;4535:20;4577:10;:::i;:::-;4565:22;;4605:12;4601:1;:16;4597:40;;;4626:11;;-1:-1:-1;;;4626:11:17;;;;;;;;;;;4597:40;4664:16;4670:4;4676:3;4664:5;:16::i;:::-;4651:9;:29;4647:56;;4689:14;;-1:-1:-1;;;4689:14:17;;;;;;;;;;;4647:56;4722:10;4713:20;;;;:8;:20;;;;;:24;;;4761:7;4765:3;4761:1;:7;:::i;:::-;4747:11;:21;4795:1;4778:59;4803:3;4798:1;:8;4778:59;;4813:24;4819:10;4831:5;4835:1;4831;:5;:::i;:::-;4813;:24::i;:::-;4808:3;;;;:::i;:::-;;;;4778:59;;;-1:-1:-1;4908:10:17;4901:41;4920:5;:1;4924;4920:5;:::i;:::-;4901:41;;;10585:25:18;;;10641:2;10626:18;;10619:34;;;4932:9:17;10669:18:18;;;10662:34;10573:2;10558:18;4901:41:17;;;;;;;4369:580;;;4325:624;:::o;3487:144:3:-;3572:52;735:10:9;3605:8:3;3615;3572:18;:52::i;4630:233::-;4743:31;4756:4;4762:2;4766:7;4743:12;:31::i;:::-;4784:72;735:10:9;4832:4:3;4838:2;4842:7;4851:4;4784:33;:72::i;2529:255::-;2593:13;2618:22;2632:7;2618:13;:22::i;:::-;;2651:21;2675:10;:8;:10::i;:::-;2651:34;;2726:1;2708:7;2702:21;:25;:75;;;;;;;;;;;;;;;;;2744:7;2753:18;:7;:16;:18::i;:::-;2730:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2702:75;2695:82;2529:255;-1:-1:-1;;;2529:255:3:o;7003:177:17:-;1531:13:0;:11;:13::i;:::-;7062:14:17::1;::::0;::::1;;7058:45;;;7085:18;;-1:-1:-1::0;;;7085:18:17::1;;;;;;;;;;;7058:45;7113:14;:21:::0;;-1:-1:-1;;7113:21:17::1;7130:4;7113:21;::::0;;7149:24:::1;::::0;::::1;::::0;::::1;::::0;7164:8:::1;::::0;7149:24:::1;:::i;:::-;;;;;;;;7003:177::o:0;5919:85::-;5965:13;5989:12;5982:19;;;;;:::i;3665:153:3:-;-1:-1:-1;;;;;3776:25:3;;;3753:4;3776:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;3665:153::o;1649:178:1:-;1531:13:0;:11;:13::i;:::-;1738::1::1;:24:::0;;-1:-1:-1;;;;;1738:24:1;::::1;-1:-1:-1::0;;;;;;1738:24:1;;::::1;::::0;::::1;::::0;;;1802:7:::1;1710:6:0::0;;-1:-1:-1;;;;;1710:6:0;;1638:85;1802:7:1::1;-1:-1:-1::0;;;;;1777:43:1::1;;;;;;;;;;;1649:178:::0;:::o;5308:156:17:-;5374:7;5397:3;5404:1;5397:8;5393:22;;-1:-1:-1;5414:1:17;5407:8;;5393:22;-1:-1:-1;;;;;5438:13:17;;;;;;:8;:13;;;;;;5432:25;;5453:3;5432:5;:25::i;1527:300:3:-;1629:4;-1:-1:-1;;;;;;1664:40:3;;-1:-1:-1;;;1664:40:3;;:104;;-1:-1:-1;;;;;;;1720:48:3;;-1:-1:-1;;;1720:48:3;1664:104;:156;;;-1:-1:-1;;;;;;;;;;829:40:12;;;1784:36:3;730:146:12;15957:241:3;16020:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:3;;16082:88;;16128:31;;-1:-1:-1;;;16128:31:3;;;;;2324:25:18;;;2297:18;;16128:31:3;2178:177:18;14138:120:3;14218:33;14227:2;14231:7;14240:4;14246;14218:8;:33::i;8507:795::-;8593:7;5470:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5470:16:3;;;;8704:18;;;8700:86;;8738:37;8755:4;8761;8767:7;8738:16;:37::i;:::-;-1:-1:-1;;;;;8830:18:3;;;8826:256;;8946:48;8963:1;8967:7;8984:1;8988:5;8946:8;:48::i;:::-;-1:-1:-1;;;;;9037:15:3;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9037:20:3;;;8826:256;-1:-1:-1;;;;;9096:16:3;;;9092:107;;-1:-1:-1;;;;;9156:13:3;;;;;;:9;:13;;;;;:18;;9173:1;9156:18;;;9092:107;9209:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9209:21:3;-1:-1:-1;;;;;9209:21:3;;;;;;;;;9246:27;;9209:16;;9246:27;;;;;;;9291:4;8507:795;-1:-1:-1;;;;8507:795:3:o;1796:162:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;735:10:9;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:9;1901:40:0;;;1679:51:18;1652:18;;1901:40:0;1533:203:18;2011:153:1;2100:13;2093:20;;-1:-1:-1;;;;;;2093:20:1;;;2123:34;2148:8;2123:24;:34::i;4955:166:17:-;5020:7;5055:9;;:25;;5077:3;5055:25;;;5067:7;5073:1;5067:3;:7;:::i;:::-;5046:5;;:35;;;;:::i;9624:327:3:-;-1:-1:-1;;;;;9691:16:3;;9687:87;;9730:33;;-1:-1:-1;;;9730:33:3;;9760:1;9730:33;;;1679:51:18;1652:18;;9730:33:3;1533:203:18;9687:87:3;9783:21;9807:32;9815:2;9819:7;9836:1;9807:7;:32::i;:::-;9783:56;-1:-1:-1;;;;;;9853:27:3;;;9849:96;;9903:31;;-1:-1:-1;;;9903:31:3;;9931:1;9903:31;;;1679:51:18;1652:18;;9903:31:3;1533:203:18;15311:411:3;-1:-1:-1;;;;;15418:19:3;;15414:90;;15460:33;;-1:-1:-1;;;15460:33:3;;15490:1;15460:33;;;1679:51:18;1652:18;;15460:33:3;1533:203:18;15414:90:3;-1:-1:-1;;;;;15517:22:3;;15513:91;;15562:31;;-1:-1:-1;;;15562:31:3;;-1:-1:-1;;;;;1697:32:18;;15562:31:3;;;1679:51:18;1652:18;;15562:31:3;1533:203:18;15513:91:3;-1:-1:-1;;;;;15613:25:3;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;15613:46:3;;;;;;;;;;15674:41;;540::18;;;15674::3;;513:18:18;15674:41:3;;;;;;;15311:411;;;:::o;994:926:7:-;-1:-1:-1;;;;;1174:14:7;;;:18;1170:744;;1212:67;;-1:-1:-1;;;1212:67:7;;-1:-1:-1;;;;;1212:36:7;;;;;:67;;1249:8;;1259:4;;1265:7;;1274:4;;1212:67;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1212:67:7;;;;;;;;-1:-1:-1;;1212:67:7;;;;;;;;;;;;:::i;:::-;;;1208:696;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1569:6;:13;1586:1;1569:18;1565:325;;1673:39;;-1:-1:-1;;;1673:39:7;;-1:-1:-1;;;;;1697:32:18;;1673:39:7;;;1679:51:18;1652:18;;1673:39:7;1533:203:18;1565:325:7;1842:6;1836:13;1829:4;1821:6;1817:17;1810:40;1208:696;-1:-1:-1;;;;;;1326:51:7;;-1:-1:-1;;;1326:51:7;1322:182;;1446:39;;-1:-1:-1;;;1446:39:7;;-1:-1:-1;;;;;1697:32:18;;1446:39:7;;;1679:51:18;1652:18;;1446:39:7;1533:203:18;1322:182:7;1280:238;1208:696;994:926;;;;;:::o;7395:87:17:-;7447:13;7471:8;7464:15;;;;;:::i;1251:634:11:-;1307:13;1356:14;1373:17;1384:5;1373:10;:17::i;:::-;1393:1;1373:21;1356:38;;1408:20;1442:6;1431:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1431:18:11;-1:-1:-1;1408:41:11;-1:-1:-1;1538:30:11;;;1554:4;1538:30;1595:247;-1:-1:-1;;1626:5:11;-1:-1:-1;;;1725:2:11;1714:14;;1709:32;1626:5;1696:46;1786:2;1777:11;;;-1:-1:-1;1806:21:11;1595:247;1806:21;-1:-1:-1;1862:6:11;1251:634;-1:-1:-1;;;1251:634:11:o;14440:662:3:-;14600:9;:31;;;-1:-1:-1;;;;;;14613:18:3;;;;14600:31;14596:460;;;14647:13;14663:22;14677:7;14663:13;:22::i;:::-;14647:38;-1:-1:-1;;;;;;14813:18:3;;;;;;:35;;;14844:4;-1:-1:-1;;;;;14835:13:3;:5;-1:-1:-1;;;;;14835:13:3;;;14813:35;:69;;;;;14853:29;14870:5;14877:4;14853:16;:29::i;:::-;14852:30;14813:69;14809:142;;;14909:27;;-1:-1:-1;;;14909:27:3;;-1:-1:-1;;;;;1697:32:18;;14909:27:3;;;1679:51:18;1652:18;;14909:27:3;1533:203:18;14809:142:3;14969:9;14965:81;;;15023:7;15019:2;-1:-1:-1;;;;;15003:28:3;15012:5;-1:-1:-1;;;;;15003:28:3;;;;;;;;;;;14965:81;14633:423;14596:460;-1:-1:-1;;15066:24:3;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15066:29:3;-1:-1:-1;;;;;15066:29:3;;;;;;;;;;14440:662::o;6751:368::-;6863:38;6877:5;6884:7;6893;6863:13;:38::i;:::-;6858:255;;-1:-1:-1;;;;;6921:19:3;;6917:186;;6967:31;;-1:-1:-1;;;6967:31:3;;;;;2324:25:18;;;2297:18;;6967:31:3;2178:177:18;6917:186:3;7044:44;;-1:-1:-1;;;7044:44:3;;-1:-1:-1;;;;;13420:32:18;;7044:44:3;;;13402:51:18;13469:18;;;13462:34;;;13375:18;;7044:44:3;13228:274:18;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;29471:916:14:-;29524:7;;-1:-1:-1;;;29599:17:14;;29595:103;;-1:-1:-1;;;29636:17:14;;;-1:-1:-1;29681:2:14;29671:12;29595:103;29724:8;29715:5;:17;29711:103;;29761:8;29752:17;;;-1:-1:-1;29797:2:14;29787:12;29711:103;29840:8;29831:5;:17;29827:103;;29877:8;29868:17;;;-1:-1:-1;29913:2:14;29903:12;29827:103;29956:7;29947:5;:16;29943:100;;29992:7;29983:16;;;-1:-1:-1;30027:1:14;30017:11;29943:100;30069:7;30060:5;:16;30056:100;;30105:7;30096:16;;;-1:-1:-1;30140:1:14;30130:11;30056:100;30182:7;30173:5;:16;30169:100;;30218:7;30209:16;;;-1:-1:-1;30253:1:14;30243:11;30169:100;30295:7;30286:5;:16;30282:66;;30332:1;30322:11;30374:6;29471:916;-1:-1:-1;;29471:916:14:o;6047:272:3:-;6150:4;-1:-1:-1;;;;;6185:21:3;;;;;;:127;;;6232:7;-1:-1:-1;;;;;6223:16:3;:5;-1:-1:-1;;;;;6223:16:3;;:52;;;;6243:32;6260:5;6267:7;6243:16;:32::i;:::-;6223:88;;;-1:-1:-1;5679:7:3;5705:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6279:32:3;;;5705:24;;6279:32;6223:88;6166:146;6047:272;-1:-1:-1;;;;6047:272:3:o;14:131:18:-;-1:-1:-1;;;;;;88:32:18;;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:18;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:18;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:18: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:18;;1348:180;-1:-1:-1;1348:180:18:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:18;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:18:o;2360:328::-;2437:6;2445;2453;2506:2;2494:9;2485:7;2481:23;2477:32;2474:52;;;2522:1;2519;2512:12;2474:52;2545:29;2564:9;2545:29;:::i;:::-;2535:39;;2593:38;2627:2;2616:9;2612:18;2593:38;:::i;:::-;2583:48;;2678:2;2667:9;2663:18;2650:32;2640:42;;2360:328;;;;;:::o;2693:186::-;2752:6;2805:2;2793:9;2784:7;2780:23;2776:32;2773:52;;;2821:1;2818;2811:12;2773:52;2844:29;2863:9;2844:29;:::i;2884:592::-;2955:6;2963;3016:2;3004:9;2995:7;2991:23;2987:32;2984:52;;;3032:1;3029;3022:12;2984:52;3072:9;3059:23;3101:18;3142:2;3134:6;3131:14;3128:34;;;3158:1;3155;3148:12;3128:34;3196:6;3185:9;3181:22;3171:32;;3241:7;3234:4;3230:2;3226:13;3222:27;3212:55;;3263:1;3260;3253:12;3212:55;3303:2;3290:16;3329:2;3321:6;3318:14;3315:34;;;3345:1;3342;3335:12;3315:34;3390:7;3385:2;3376:6;3372:2;3368:15;3364:24;3361:37;3358:57;;;3411:1;3408;3401:12;3358:57;3442:2;3434:11;;;;;3464:6;;-1:-1:-1;2884:592:18;;-1:-1:-1;;;;2884:592:18:o;3705:347::-;3770:6;3778;3831:2;3819:9;3810:7;3806:23;3802:32;3799:52;;;3847:1;3844;3837:12;3799:52;3870:29;3889:9;3870:29;:::i;:::-;3860:39;;3949:2;3938:9;3934:18;3921:32;3996:5;3989:13;3982:21;3975:5;3972:32;3962:60;;4018:1;4015;4008:12;3962:60;4041:5;4031:15;;;3705:347;;;;;:::o;4057:127::-;4118:10;4113:3;4109:20;4106:1;4099:31;4149:4;4146:1;4139:15;4173:4;4170:1;4163:15;4189:1138;4284:6;4292;4300;4308;4361:3;4349:9;4340:7;4336:23;4332:33;4329:53;;;4378:1;4375;4368:12;4329:53;4401:29;4420:9;4401:29;:::i;:::-;4391:39;;4449:38;4483:2;4472:9;4468:18;4449:38;:::i;:::-;4439:48;;4534:2;4523:9;4519:18;4506:32;4496:42;;4589:2;4578:9;4574:18;4561:32;4612:18;4653:2;4645:6;4642:14;4639:34;;;4669:1;4666;4659:12;4639:34;4707:6;4696:9;4692:22;4682:32;;4752:7;4745:4;4741:2;4737:13;4733:27;4723:55;;4774:1;4771;4764:12;4723:55;4810:2;4797:16;4832:2;4828;4825:10;4822:36;;;4838:18;;:::i;:::-;4913:2;4907:9;4881:2;4967:13;;-1:-1:-1;;4963:22:18;;;4987:2;4959:31;4955:40;4943:53;;;5011:18;;;5031:22;;;5008:46;5005:72;;;5057:18;;:::i;:::-;5097:10;5093:2;5086:22;5132:2;5124:6;5117:18;5172:7;5167:2;5162;5158;5154:11;5150:20;5147:33;5144:53;;;5193:1;5190;5183:12;5144:53;5249:2;5244;5240;5236:11;5231:2;5223:6;5219:15;5206:46;5294:1;5289:2;5284;5276:6;5272:15;5268:24;5261:35;5315:6;5305:16;;;;;;;4189:1138;;;;;;;:::o;5332:260::-;5400:6;5408;5461:2;5449:9;5440:7;5436:23;5432:32;5429:52;;;5477:1;5474;5467:12;5429:52;5500:29;5519:9;5500:29;:::i;:::-;5490:39;;5548:38;5582:2;5571:9;5567:18;5548:38;:::i;:::-;5538:48;;5332:260;;;;;:::o;5597:380::-;5676:1;5672:12;;;;5719;;;5740:61;;5794:4;5786:6;5782:17;5772:27;;5740:61;5847:2;5839:6;5836:14;5816:18;5813:38;5810:161;;5893:10;5888:3;5884:20;5881:1;5874:31;5928:4;5925:1;5918:15;5956:4;5953:1;5946:15;5810:161;;5597:380;;;:::o;6916:127::-;6977:10;6972:3;6968:20;6965:1;6958:31;7008:4;7005:1;6998:15;7032:4;7029:1;7022:15;7048:128;7115:9;;;7136:11;;;7133:37;;;7150:18;;:::i;7307:518::-;7409:2;7404:3;7401:11;7398:421;;;7445:5;7442:1;7435:16;7489:4;7486:1;7476:18;7559:2;7547:10;7543:19;7540:1;7536:27;7530:4;7526:38;7595:4;7583:10;7580:20;7577:47;;;-1:-1:-1;7618:4:18;7577:47;7673:2;7668:3;7664:12;7661:1;7657:20;7651:4;7647:31;7637:41;;7728:81;7746:2;7739:5;7736:13;7728:81;;;7805:1;7791:16;;7772:1;7761:13;7728:81;;8001:1198;8125:18;8120:3;8117:27;8114:53;;;8147:18;;:::i;:::-;8176:94;8266:3;8226:38;8258:4;8252:11;8226:38;:::i;:::-;8220:4;8176:94;:::i;:::-;8296:1;8321:2;8316:3;8313:11;8338:1;8333:608;;;;8985:1;9002:3;8999:93;;;-1:-1:-1;9058:19:18;;;9045:33;8999:93;-1:-1:-1;;7958:1:18;7954:11;;;7950:24;7946:29;7936:40;7982:1;7978:11;;;7933:57;9105:78;;8306:887;;8333:608;7254:1;7247:14;;;7291:4;7278:18;;-1:-1:-1;;8369:17:18;;;8484:229;8498:7;8495:1;8492:14;8484:229;;;8587:19;;;8574:33;8559:49;;8694:4;8679:20;;;;8647:1;8635:14;;;;8514:12;8484:229;;;8488:3;8741;8732:7;8729:16;8726:159;;;8865:1;8861:6;8855:3;8849;8846:1;8842:11;8838:21;8834:34;8830:39;8817:9;8812:3;8808:19;8795:33;8791:79;8783:6;8776:95;8726:159;;;8928:1;8922:3;8919:1;8915:11;8911:19;8905:4;8898:33;8306:887;;8001:1198;;;:::o;9204:390::-;9363:2;9352:9;9345:21;9402:6;9397:2;9386:9;9382:18;9375:34;9459:6;9451;9446:2;9435:9;9431:18;9418:48;9515:1;9486:22;;;9510:2;9482:31;;;9475:42;;;;9578:2;9557:15;;;-1:-1:-1;;9553:29:18;9538:45;9534:54;;9204:390;-1:-1:-1;9204:390:18:o;10113:125::-;10178:9;;;10199:10;;;10196:36;;;10212:18;;:::i;10243:135::-;10282:3;10303:17;;;10300:43;;10323:18;;:::i;:::-;-1:-1:-1;10370:1:18;10359:13;;10243:135::o;10707:496::-;10886:3;10924:6;10918:13;10940:66;10999:6;10994:3;10987:4;10979:6;10975:17;10940:66;:::i;:::-;11069:13;;11028:16;;;;11091:70;11069:13;11028:16;11138:4;11126:17;;11091:70;:::i;:::-;11177:20;;10707:496;-1:-1:-1;;;;10707:496:18:o;11208:962::-;11317:4;11346:2;11375;11364:9;11357:21;11398:1;11431:6;11425:13;11461:36;11487:9;11461:36;:::i;:::-;11533:6;11528:2;11517:9;11513:18;11506:34;11559:2;11580:1;11612;11601:9;11597:17;11628:1;11623:158;;;;11795:1;11790:354;;;;11590:554;;11623:158;11690:3;11686:8;11675:9;11671:24;11666:2;11655:9;11651:18;11644:52;11768:2;11756:6;11749:14;11742:22;11739:1;11735:30;11724:9;11720:46;11716:55;11709:62;;11623:158;;11790:354;11821:6;11818:1;11811:17;11869:2;11866:1;11856:16;11894:1;11908:180;11922:6;11919:1;11916:13;11908:180;;;12015:14;;11991:17;;;11987:26;;11980:50;12058:16;;;;11937:10;;11908:180;;;12112:17;;12131:2;12108:26;;-1:-1:-1;;11590:554:18;-1:-1:-1;12161:3:18;;11208:962;-1:-1:-1;;;;;;;;11208:962:18:o;12175:168::-;12248:9;;;12279;;12296:15;;;12290:22;;12276:37;12266:71;;12317:18;;:::i;12348:489::-;-1:-1:-1;;;;;12617:15:18;;;12599:34;;12669:15;;12664:2;12649:18;;12642:43;12716:2;12701:18;;12694:34;;;12764:3;12759:2;12744:18;;12737:31;;;12542:4;;12785:46;;12811:19;;12803:6;12785:46;:::i;:::-;12777:54;12348:489;-1:-1:-1;;;;;;12348:489:18:o;12842:249::-;12911:6;12964:2;12952:9;12943:7;12939:23;12935:32;12932:52;;;12980:1;12977;12970:12;12932:52;13012:9;13006:16;13031:30;13055:5;13031:30;:::i","linkReferences":{},"immutableReferences":{"7592":[{"start":1423,"length":32},{"start":2478,"length":32},{"start":2649,"length":32},{"start":3130,"length":32}],"7595":[{"start":884,"length":32},{"start":3232,"length":32}],"7598":[{"start":1720,"length":32},{"start":3061,"length":32}],"7601":[{"start":1352,"length":32}],"7604":[{"start":1556,"length":32},{"start":2908,"length":32}],"7607":[{"start":986,"length":32},{"start":2177,"length":32},{"start":2340,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"acceptOwnership()","signatureHash4":"0x79ba5097","signatureHash32":"0x79ba5097e5519a381a52113cdcc59540d13f73fd9d26abc0453484a096cc96f2"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"contractURI()","signatureHash4":"0xe8a3d485","signatureHash32":"0xe8a3d48517095c5a7fd44e6a6e1538451380e285023a89d5b1c3b9b38d440cf4"},{"signature":"costFor(address,uint256)","signatureHash4":"0xf31cc4e6","signatureHash32":"0xf31cc4e63a0088baae931c1b0ea75a851dede8675d1fe1945584bfad9023487d"},{"signature":"freezeMetadata()","signatureHash4":"0xd111515d","signatureHash32":"0xd111515d688211303bb55d43956bbbcab416867088c61ce8a0486e621d0ca153"},{"signature":"getApproved(uint256)","signatureHash4":"0x081812fc","signatureHash32":"0x081812fc55e34fdc7cf5d8b5cf4e3621fa6423fde952ec6ab24afdc0d85c0b2e"},{"signature":"hasFreeMint(address)","signatureHash4":"0xd5cde1f2","signatureHash32":"0xd5cde1f213ca9bfdf58c3cc674091664df92238534021a2c8763f4f8401f9120"},{"signature":"isApprovedForAll(address,address)","signatureHash4":"0xe985e9c5","signatureHash32":"0xe985e9c5c6636c6879256001057b28ccac7718ef0ac56553ff9b926452cab8a3"},{"signature":"maxPerTx()","signatureHash4":"0xf968adbe","signatureHash32":"0xf968adbedd3a26f21400b998b7dddf5121ebb998eb81a20511ac785dca4d1ebd"},{"signature":"maxPerWallet()","signatureHash4":"0x453c2310","signatureHash32":"0x453c2310c76d45af75fb2dcb8a88ec1be5bd4f1b8a138e2abb7c144172dc4796"},{"signature":"maxPrice()","signatureHash4":"0xe38d6b5c","signatureHash32":"0xe38d6b5ca10f21b99ff8db4565f5d42352438f29bea220da3b7550521e4ec5b3"},{"signature":"maxSupply()","signatureHash4":"0xd5abeb01","signatureHash32":"0xd5abeb019d507b76d3c173387b805b2b51d2b70f218401ea3504c69c56d36777"},{"signature":"metadataFrozen()","signatureHash4":"0xfb3cc6c2","signatureHash32":"0xfb3cc6c26cfd6815fea39b5bb787d0527422d0518dfd8c894455a92e0495ed65"},{"signature":"mintedBy(address)","signatureHash4":"0x3cef28d2","signatureHash32":"0x3cef28d2a347eb7b15200f788ef3c7d0d847423cdf0ff5ffe4229b4ce296ca90"},{"signature":"mint(uint256)","signatureHash4":"0xa0712d68","signatureHash32":"0xa0712d680358d64f694230b7cc0b277c73686bdf768385d55cd7c547d0ffd30e"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"ownerOf(uint256)","signatureHash4":"0x6352211e","signatureHash32":"0x6352211e6566aa027e75ac9dbf2423197fbd9b82b9d981a3ab367d355866aa1c"},{"signature":"pendingOwner()","signatureHash4":"0xe30c3978","signatureHash32":"0xe30c3978ddd82956a01b5cb08d17f1a2d73e636aeefb7b36f896e41d4c2aab90"},{"signature":"price()","signatureHash4":"0xa035b1fe","signatureHash32":"0xa035b1fe6fc95504ec34c01f5f457ced39c26a91e52e2bdf1623238a202c7c3c"},{"signature":"remaining()","signatureHash4":"0x55234ec0","signatureHash32":"0x55234ec0ea1e12fc3f89ea87d7a93d4baff46b9e3de9792aaf4a5a8e6e12e989"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"reserve()","signatureHash4":"0xcd3293de","signatureHash32":"0xcd3293dee7528e511e08887b8059f8124c81465e588877e31c302aac0fcbc7d2"},{"signature":"safeTransferFrom(address,address,uint256)","signatureHash4":"0x42842e0e","signatureHash32":"0x42842e0eb38857a7775b4e7364b2775df7325074d088e7fb39590cd6281184ed"},{"signature":"safeTransferFrom(address,address,uint256,bytes)","signatureHash4":"0xb88d4fde","signatureHash32":"0xb88d4fde60196325a28bb7f99a2582e0b46de55b18761e960c14ad7a32099465"},{"signature":"setApprovalForAll(address,bool)","signatureHash4":"0xa22cb465","signatureHash32":"0xa22cb4651ab9570f89bb516380c40ce76762284fb1f21337ceaf6adab99e7d4a"},{"signature":"setBaseURI(string)","signatureHash4":"0x55f804b3","signatureHash32":"0x55f804b373ab21b346f6f172ca5e118cfcad05163bcea59b35420499bf7e074b"},{"signature":"setPrice(uint256)","signatureHash4":"0x91b7f5ed","signatureHash32":"0x91b7f5edf6974124907a39e5cd7c4074d2d4f20c2b6167d094491246c3bb329e"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"tokenURI(uint256)","signatureHash4":"0xc87b56dd","signatureHash32":"0xc87b56dda752230262935940d907f047a9f86bb5ee6aa33511fc86db33fea6cc"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"treasury()","signatureHash4":"0x61d027b3","signatureHash32":"0x61d027b30ea0954414618cb8201bc912d75d6474f7f913dfdc4b5172d13bee5b"},{"signature":"withdraw()","signatureHash4":"0x3ccfd60b","signatureHash32":"0x3ccfd60b2e3ddce51ab210bfb9db13577f03a21684fa35e4bcd739dd5a30bda2"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"ApprovalForAll(address,address,bool)","signatureHash4":"0x17307eab","signatureHash32":"0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31"},{"signature":"BaseURIChanged(string)","signatureHash4":"0x5411e8eb","signatureHash32":"0x5411e8ebf1636d9e83d5fc4900bf80cbac82e8790da2a4c94db4895e889eedf6"},{"signature":"BatchMetadataUpdate(uint256,uint256)","signatureHash4":"0x6bd5c950","signatureHash32":"0x6bd5c950a8d8df17f772f5af37cb3655737899cbf903264b9795592da439661c"},{"signature":"MetadataFrozen(string)","signatureHash4":"0xac323281","signatureHash32":"0xac32328134cd103aa01cccc8f61d479f9613e7f9c1de6bfc70c78412b15c18e3"},{"signature":"Minted(address,uint256,uint256,uint256)","signatureHash4":"0x5a3358a3","signatureHash32":"0x5a3358a3d27a5373c0df2604662088d37894d56b7cfd27f315770440f4e0d919"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"OwnershipTransferStarted(address,address)","signatureHash4":"0x38d16b8c","signatureHash32":"0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700"},{"signature":"PriceChanged(uint256,uint256)","signatureHash4":"0x8aa4fa52","signatureHash32":"0x8aa4fa52648a6d15edce8a179c792c86f3719d0cc3c572cf90f91948f0f2cb68"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"},{"signature":"Withdrawn(address,uint256)","signatureHash4":"0x7084f547","signatureHash32":"0x7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5"}],"error":[{"signature":"BadConfig()","signatureHash4":"0x07cc321c","signatureHash32":"0x07cc321ce71a3eebb30014b3b8f136f5e867b17e2b76292bf086143aa7c7b50c"},{"signature":"BadQty()","signatureHash4":"0x12936432","signatureHash32":"0x1293643218a3b98111baee88578217d1a28e113404c0f7b1e9a6f71e1b634fbc"},{"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":"MetadataIsFrozen()","signatureHash4":"0xb087bbf3","signatureHash32":"0xb087bbf360bb7905ca0dda44229afd8049df266e8f1bbb35defcf0c9c88f61c3"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"},{"signature":"PriceTooHigh()","signatureHash4":"0x24fe1192","signatureHash32":"0x24fe1192973640e5449362933e83aded5a241e2cc884f1cec4081df587c5c6b7"},{"signature":"SoldOut()","signatureHash4":"0x52df9fe5","signatureHash32":"0x52df9fe5b9c9a7b0b4fdc2c9f89387959e35e4209c2a8d133a2b8165edad2a04"},{"signature":"WalletCap()","signatureHash4":"0x94048683","signatureHash32":"0x94048683f36329b560d86f2166984d280118cea63ada92e5894f3e175d501c9b"},{"signature":"WrongPayment()","signatureHash4":"0x788a686f","signatureHash32":"0x788a686fba1305d4a6b4ea40442947af1f8ab9c56da8d20a6fd1c28996cf497f"},{"signature":"ZeroAddress()","signatureHash4":"0xd92e233d","signatureHash32":"0xd92e233df2717d4a40030e20904abd27b68fcbeede117eaaccbbdac9618c8c73"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0x5ae2be6BbA1BD4f561Dc13158c7f5B95992e045B"}