{"matchId":"58863926","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-11-09T08:39:54Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"545:7483:12:-:0;;;2514:303;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2666:12;2647:9;1582:113:2;;;;;;;;;;;;;-1:-1:-1;;;1582:113:2;;;;;;;;;;;;;;;;-1:-1:-1;;;1582:113:2;;;1656:5;1648;:13;;;;;;:::i;:::-;-1:-1:-1;1671:7:2;:17;1681:7;1671;:17;:::i;:::-;;1582:113;;982:1:10;958:9;-1:-1:-1;;;;;958:21:10;;:25;950:58;;;;-1:-1:-1;;;950:58:10;;3422:2:13;950:58:10;;;3404:21:13;3461:2;3441:18;;;3434:30;3500:22;3480:18;;;3473:50;3540:18;;950:58:10;;;;;;;;;1022:13;1039:2;1022:19;1018:212;;-1:-1:-1;;;;;1065:33:10;;648:42;1065:33;1057:71;;;;-1:-1:-1;;;1057:71:10;;3771:2:13;1057:71:10;;;3753:21:13;3810:2;3790:18;;;3783:30;3849:27;3829:18;;;3822:55;3894:18;;1057:71:10;3569:349:13;1057:71:10;-1:-1:-1;;;;;1150:18:10;;;744:66;1150:43;1142:77;;;;-1:-1:-1;;;1142:77:10;;4125:2:13;1142:77:10;;;4107:21:13;4164:2;4144:18;;;4137:30;4203:23;4183:18;;;4176:51;4244:18;;1142:77:10;3923:345:13;1142:77:10;-1:-1:-1;;;;;1239:36:10;;;;;;;1304:18;1285:37;;1273:26:0;;1269:95;;1322:31;;-1:-1:-1;;;1322:31:0;;1350:1;1322:31;;;4419:51:13;4392:18;;1322:31:0;4273:203:13;1269:95:0;1373:32;1392:12;1373:18;:32::i;:::-;-1:-1:-1;;;;;;2702:18:12;::::3;2694:39;;;::::0;-1:-1:-1;;;2694:39:12;;4683:2:13;2694:39:12::3;::::0;::::3;4665:21:13::0;4722:1;4702:18;;;4695:29;-1:-1:-1;;;4740:18:13;;;4733:38;4788:18;;2694:39:12::3;4481:331:13::0;2694:39:12::3;-1:-1:-1::0;;;;;2743:10:12;::::3;;::::0;2763:29:::3;2749:4:::0;725:22:::3;2763:5;:29::i;:::-;2802:8;:6;:8::i;:::-;2514:303:::0;;;545:7483;;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;7362:208:2:-;-1:-1:-1;;;;;7432:21:2;;7428:91;;7476:32;;-1:-1:-1;;;7476:32:2;;7505:1;7476:32;;;4419:51:13;4392:18;;7476:32:2;4273:203:13;7428:91:2;7528:35;7544:1;7548:7;7557:5;7528:7;:35::i;:::-;7362:208;;:::o;2339:115:7:-;1350:19;:17;:19::i;:::-;2398:7:::1;:14:::0;;-1:-1:-1;;;;2398:14:7::1;-1:-1:-1::0;;;2398:14:7::1;::::0;;2427:20:::1;2434:12;735:10:5::0;;656:96;2434:12:7::1;2427:20;::::0;-1:-1:-1;;;;;4437:32:13;;;4419:51;;4407:2;4392:18;2427:20:7::1;;;;;;;2339:115::o:0;5912:1107:2:-;-1:-1:-1;;;;;6001:18:2;;5997:540;;6153:5;6137:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;5997:540:2;;-1:-1:-1;5997:540:2;;-1:-1:-1;;;;;6211:15:2;;6189:19;6211:15;;;;;;;;;;;6244:19;;;6240:115;;;6290:50;;-1:-1:-1;;;6290:50:2;;-1:-1:-1;;;;;5264:32:13;;6290:50:2;;;5246:51:13;5313:18;;;5306:34;;;5356:18;;;5349:34;;;5219:18;;6290:50:2;5044:345:13;6240:115:2;-1:-1:-1;;;;;6475:15:2;;:9;:15;;;;;;;;;;6493:19;;;;6475:37;;5997:540;-1:-1:-1;;;;;6551:16:2;;6547:425;;6714:12;:21;;;;;;;6547:425;;;-1:-1:-1;;;;;6925:13:2;;:9;:13;;;;;;;;;;:22;;;;;;6547:425;7002:2;-1:-1:-1;;;;;6987:25:2;6996:4;-1:-1:-1;;;;;6987:25:2;;7006:5;6987:25;;;;5540::13;;5528:2;5513:18;;5394:177;6987:25:2;;;;;;;;5912:1107;;;:::o;1878:128:7:-;1943:8;1796:7;;-1:-1:-1;;;1796:7:7;;;;;1726:84;1943:8;1939:61;;;1974:15;;-1:-1:-1;;;1974:15:7;;;;;;;;;;;1939:61;1878:128::o;14:177:13:-;93:13;;-1:-1:-1;;;;;135:31:13;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:378::-;284:6;292;300;353:2;341:9;332:7;328:23;324:32;321:52;;;369:1;366;359:12;321:52;392:40;422:9;392:40;:::i;:::-;382:50;;451:49;496:2;485:9;481:18;451:49;:::i;:::-;441:59;;519:49;564:2;553:9;549:18;519:49;:::i;:::-;509:59;;196:378;;;;;:::o;579:127::-;640:10;635:3;631:20;628:1;621:31;671:4;668:1;661:15;695:4;692:1;685:15;711:380;790:1;786:12;;;;833;;;854:61;;908:4;900:6;896:17;886:27;;854:61;961:2;953:6;950:14;930:18;927:38;924:161;;1007:10;1002:3;998:20;995:1;988:31;1042:4;1039:1;1032:15;1070:4;1067:1;1060:15;924:161;;711:380;;;:::o;1222:518::-;1324:2;1319:3;1316:11;1313:421;;;1360:5;1357:1;1350:16;1404:4;1401:1;1391:18;1474:2;1462:10;1458:19;1455:1;1451:27;1445:4;1441:38;1510:4;1498:10;1495:20;1492:47;;;-1:-1:-1;1533:4:13;1492:47;1588:2;1583:3;1579:12;1576:1;1572:20;1566:4;1562:31;1552:41;;1643:81;1661:2;1654:5;1651:13;1643:81;;;1720:1;1706:16;;1687:1;1676:13;1643:81;;;1647:3;;1313:421;1222:518;;;:::o;1916:1299::-;2036:10;;-1:-1:-1;;;;;2058:30:13;;2055:56;;;2091:18;;:::i;:::-;2120:97;2210:6;2170:38;2202:4;2196:11;2170:38;:::i;:::-;2164:4;2120:97;:::i;:::-;2266:4;2297:2;2286:14;;2314:1;2309:649;;;;3002:1;3019:6;3016:89;;;-1:-1:-1;3071:19:13;;;3065:26;3016:89;-1:-1:-1;;1873:1:13;1869:11;;;1865:24;1861:29;1851:40;1897:1;1893:11;;;1848:57;3118:81;;2279:930;;2309:649;1169:1;1162:14;;;1206:4;1193:18;;-1:-1:-1;;2345:20:13;;;2463:222;2477:7;2474:1;2471:14;2463:222;;;2559:19;;;2553:26;2538:42;;2666:4;2651:20;;;;2619:1;2607:14;;;;2493:12;2463:222;;;2467:3;2713:6;2704:7;2701:19;2698:201;;;2774:19;;;2768:26;-1:-1:-1;;2857:1:13;2853:14;;;2869:3;2849:24;2845:37;2841:42;2826:58;2811:74;;2698:201;-1:-1:-1;;;;2945:1:13;2929:14;;;2925:22;2912:36;;-1:-1:-1;1916:1299:13:o;4817:222::-;4882:9;;;4903:10;;;4900:133;;;4955:10;4950:3;4946:20;4943:1;4936:31;4990:4;4987:1;4980:15;5018:4;5015:1;5008:15;4900:133;4817:222;;;;:::o;5394:177::-;545:7483:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122032f17b348a9f6832b639708f91c7fa94c236cb948dd8a373be5bda41d5cedb5464736f6c634300081e0033","offset":9413}},"transformations":[{"type":"insert","offset":9466,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x00000000000000000000000060b9262456de011f7d15a54cdd8c48baaa8b022f000000000000000000000000d6386bdf654ddc89e66dcbba83f4c311088b2cfa000000000000000000000000d6386bdf654ddc89e66dcbba83f4c311088b2cfa"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"545:7483:12:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5775:158;;;:::i;:::-;;;160:25:13;;;148:2;133:18;5775:158:12;;;;;;;;1760:89:2;;;:::i;:::-;;;;;;;:::i;4655:150:12:-;;;:::i;862:41:10:-;;;;;3902:186:2;;;;;;:::i;:::-;;:::i;:::-;;;1707:14:13;;1700:22;1682:41;;1670:2;1655:18;3902:186:2;1542:187:13;3256:121:12;;;:::i;:::-;;2803:97:2;2881:12;;2803:97;;1177:50:12;;1226:1;1177:50;;2900:350;;;:::i;4680:244:2:-;;;;;;:::i;:::-;;:::i;954:45:12:-;;997:2;954:45;;2823:71;;;2889:2;2389:36:13;;2377:2;2362:18;2823:71:12;2247:184:13;682:65:12;;725:22;682:65;;615:61;;652:24;615:61;;882:66;;927:21;882:66;;821:55;;862:14;821:55;;5421:97;;;:::i;1123:48::-;;1170:1;1123:48;;1296:37;;1332:1;1296:37;;1473:135;;1514:94;1473:135;;3383:124;;;:::i;1744:27::-;;;;;;1707:31;;;;;;5322:94;;;:::i;1726:84:7:-;1796:7;;-1:-1:-1;;;1796:7:7;;;;1726:84;;1825:41:12;;;;;;:::i;:::-;;;;;;;;;;;;;;2933:116:2;;;;;;:::i;:::-;-1:-1:-1;;;;;3024:18:2;2998:7;3024:18;;;;;;;;;;;;2933:116;3615:110:12;;;:::i;816:40:10:-;;;;;;;;-1:-1:-1;;;;;2875:32:13;;;2857:51;;2845:2;2830:18;816:40:10;2688:226:13;6596:1430:12;;;;;;:::i;:::-;;:::i;3961:321::-;;;;;;:::i;:::-;;:::i;1638:85:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;1638:85;;3731:155:12;;;;;;:::i;:::-;;:::i;1615:28::-;;;;;601:89:10;;648:42;601:89;;5523:80:12;5588:12;;5523:80;;1962:93:2;;;:::i;696:114:10:-;;744:66;696:114;;1339:41:12;;1378:2;1339:41;;3244:178:2;;;;;;:::i;:::-;;:::i;6278:312:12:-;;;;;;:::i;:::-;;:::i;:::-;;;;4225:25:13;;;4281:2;4266:18;;4259:34;;;;4309:18;;;4302:34;;;;4379:14;4372:22;4367:2;4352:18;;4345:50;4439:14;4432:22;4426:3;4411:19;;4404:51;4486:3;4471:19;;4464:35;4212:3;4197:19;6278:312:12;3950:555:13;4412:160:12;;;:::i;1649:23::-;;;;;;5608:161;;;:::i;1678:23::-;;;;;;753:62;;793:22;753:62;;1777:42;;;;;;:::i;:::-;;;;;;;;;;;;;;;;1005:38;;1041:2;1005:38;;1872:44;;;;;;:::i;:::-;;;;;;;;;;;;;;5939:173;;;;;;:::i;:::-;;:::i;1233:57::-;;;:::i;5074:243::-;;;;;;:::i;:::-;;:::i;3455:140:2:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3561:18:2;;;3535:7;3561:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3455:140;1334:530:10;;;;;;:::i;:::-;;:::i;4933:136:12:-;;;;;;:::i;:::-;;:::i;2543:215:0:-;;;;;;:::i;:::-;;:::i;4288:118:12:-;;;:::i;1049:68::-;;-1:-1:-1;;;;;1049:68:12;;1386:81;;1425:42;1386:81;;6118:154;;;;;;:::i;:::-;;:::i;5775:158::-;5916:8;;5859:66;;;1514:94;5859:66;;;5319:25:13;5886:13:12;5360:18:13;;;5353:34;;;;5909:4:12;5403:18:13;;;5396:60;5472:18;;;5465:34;;;;5823:7:12;;5291:19:13;;5859:66:12;;;;;;;;;;;;5849:77;;;;;;5842:84;;5775:158;:::o;1760:89:2:-;1805:13;1837:5;1830:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1760:89;:::o;4655:150:12:-;4701:7;4720:13;4736:20;:18;:20::i;:::-;4720:36;;4781:17;4792:5;4781:10;:17::i;:::-;4773:25;;:5;:25;:::i;:::-;4766:32;;;4655:150;:::o;3902:186:2:-;3975:4;735:10:5;4029:31:2;735:10:5;4045:7:2;4054:5;4029:8;:31::i;:::-;4077:4;4070:11;;;3902:186;;;;;:::o;3256:121:12:-;1531:13:0;:11;:13::i;:::-;3312:8:12::1;;3324:1;3312:13:::0;3308:44:::1;;3334:18;;-1:-1:-1::0;;;3334:18:12::1;;;;;;;;;;;3308:44;3362:8;:6;:8::i;:::-;3256:121::o:0;2900:350::-;1531:13:0;:11;:13::i;:::-;2956:8:12::1;::::0;:13;2952:48:::1;;2978:22;;-1:-1:-1::0;;;2978:22:12::1;;;;;;;;;;;2952:48;3021:15;3010:8;:26:::0;1514:94:::1;3094:13;3117:4;3146:16;3161:1;3146:12;:16;:::i;:::-;3165:8;::::0;3067:107:::1;::::0;;::::1;::::0;::::1;6419:25:13::0;;;;6460:18;;6453:34;;;;-1:-1:-1;;;;;6523:32:13;;;6503:18;;;6496:60;3136:27:12::1;6572:18:13::0;;;6565:34;6615:19;;;6608:35;6391:19;;3067:107:12::1;::::0;;-1:-1:-1;;3067:107:12;;::::1;::::0;;;;;;3057:118;;3067:107:::1;3057:118:::0;;::::1;::::0;3046:8:::1;:129:::0;3185:10:::1;:8;:10::i;:::-;3210:33;3224:8;;3234;;3210:33;;;;;;6828:25:13::0;;;6884:2;6869:18;;6862:34;6816:2;6801:18;;6654:248;3210:33:12::1;;;;;;;;2900:350::o:0;4680:244:2:-;4767:4;735:10:5;4823:37:2;4839:4;735:10:5;4854:5:2;4823:15;:37::i;:::-;4870:26;4880:4;4886:2;4890:5;4870:9;:26::i;:::-;4913:4;4906:11;;;4680:244;;;;;;:::o;5421:97:12:-;5467:7;5485:30;5500:14;:12;:14::i;5485:30::-;5478:37;;5421:97;:::o;3383:124::-;1531:13:0;:11;:13::i;:::-;3440:8:12::1;;3452:1;3440:13:::0;3436:44:::1;;3462:18;;-1:-1:-1::0;;;3462:18:12::1;;;;;;;;;;;3436:44;3490:10;:8;:10::i;5322:94::-:0;5367:7;5385:28;5400:12;;5385:14;:28::i;3615:110::-;1531:13:0;:11;:13::i;:::-;3687:31:12::1;;-1:-1:-1::0;;;3687:31:12::1;;;;;;;;;;;6596:1430:::0;1350:19:7;:17;:19::i;:::-;6716:8:12::1;;6728:1;6716:13:::0;6712:44:::1;;6738:18;;-1:-1:-1::0;;;6738:18:12::1;;;;;;;;;;;6712:44;6777:10;6770:18;::::0;;;:6:::1;:18;::::0;;;;;:35;::::1;6766:60;;6814:12;;-1:-1:-1::0;;;6814:12:12::1;;;;;;;;;;;6766:60;6841:27;::::0;-1:-1:-1;;;6841:27:12;;6854:10:::1;6841:27;::::0;::::1;7081:51:13::0;7148:18;;;7141:34;;;6841:4:12::1;::::0;:12:::1;::::0;7054:18:13;;6841:27:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6836:58;;6877:17;;-1:-1:-1::0;;;6877:17:12::1;;;;;;;;;;;6836:58;6920:16;::::0;6977:12:::1;::::0;6904:13:::1;::::0;6962:28:::1;::::0;:14:::1;:28::i;:::-;6946:44;;7000:13;7016:29;7028:10;7039:5;7016:11;:29::i;:::-;7059:17;::::0;;;:10:::1;:17;::::0;;;;;7000:45;;-1:-1:-1;7059:17:12::1;;7055:48;;;7085:18;;-1:-1:-1::0;;;7085:18:12::1;;;;;;;;;;;7055:48;7134:21;7149:5;7134:14;:21::i;:::-;7117:38:::0;::::1;7113:68;;;7164:17;;-1:-1:-1::0;;;7164:17:12::1;;;;;;;;;;;7113:68;793:22;7195:12;;:29;7191:58;;7233:16;;-1:-1:-1::0;;;7233:16:12::1;;;;;;;;;;;7191:58;7259:13;7275:20;:18;:20::i;:::-;7259:36;;7305:14;7322:17;7333:5;7322:10;:17::i;:::-;7305:34:::0;-1:-1:-1;7349:14:12::1;7366;7305:34:::0;7366:5;:14:::1;:::i;:::-;7349:31;;7403:9;7394:6;:18;7390:46;;;7421:15;;-1:-1:-1::0;;;7421:15:12::1;;;;;;;;;;;7390:46;7446:17;::::0;;;:10:::1;:17;::::0;;;;:24;;-1:-1:-1;;7446:24:12::1;7466:4;7446:24:::0;;::::1;::::0;;;7501:17:::1;::::0;:13;;:17:::1;:::i;:::-;7487:10;7480:18;::::0;;;:6:::1;:18;::::0;;;;;;;:38;;;;7528:9:::1;:21:::0;;;:29;;;7586:9:::1;:5:::0;7594:1:::1;7586:9;:::i;:::-;7567:16;:28;;;;7621:5;7605:12;;:21;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;7663:12:12::1;::::0;652:24:::1;::::0;7644:31:::1;::::0;725:22:::1;7644:31;:::i;:::-;:45;;7636:68;;;::::0;-1:-1:-1;;;7636:68:12;;7800:2:13;7636:68:12::1;::::0;::::1;7782:21:13::0;7839:2;7819:18;;;7812:30;-1:-1:-1;;;7858:18:13;;;7851:40;7908:18;;7636:68:12::1;;;;;;;;;7719:45;::::0;;8139:25:13;;;8195:2;8180:18;;8173:34;;;8223:18;;;8216:34;;;7739:5:12;;7736:2;;7725:10:::1;::::0;7719:45:::1;::::0;8127:2:13;8112:18;7719:45:12::1;;;;;;;7774:17;7794:28;7809:12;;7794:14;:28::i;:::-;7774:48;;7849:5;7836:9;:18;7832:98;;7861:69;7884:9;7894:25;7909:9;7894:14;:25::i;:::-;7920:9;:5:::0;7928:1:::1;7920:9;:::i;:::-;7861:69;::::0;;8139:25:13;;;8195:2;8180:18;;8173:34;;;;8223:18;;;8216:34;8127:2;8112:18;7861:69:12::1;;;;;;;7832:98;7940:25;7946:10;7958:6;7940:5;:25::i;:::-;7979:11:::0;;7975:44:::1;;7992:27;1425:42;8012:6;7992:5;:27::i;:::-;6702:1324;;;;;;;6596:1430:::0;;;;:::o;3961:321::-;4021:14;997:2;4051:5;:24;4047:51;;;4084:14;;-1:-1:-1;;;4084:14:12;;;;;;;;;;;4047:51;-1:-1:-1;862:14:12;4224:9;4219:56;4239:5;4235:1;:9;4219:56;;;4273:2;4260:10;:6;4269:1;4260:10;:::i;:::-;:15;;;;:::i;:::-;4251:24;-1:-1:-1;4246:3:12;;4219:56;;;;3961:321;;;:::o;3731:155::-;3798:7;3824:55;997:2;3851:27;927:21;3851:6;:27;:::i;:::-;3824:8;:55::i;1962:93:2:-;2009:13;2041:7;2034:14;;;;;:::i;3244:178::-;3313:4;735:10:5;3367:27:2;735:10:5;3384:2:2;3388:5;3367:9;:27::i;6278:312:12:-;6357:12;6371:14;6387;6403:13;6418:9;6429:13;6467:18;6478:6;6467:10;:18::i;:::-;6487:15;:13;:15::i;:::-;6504;:13;:15::i;:::-;6521:23;;-1:-1:-1;;;6521:23:12;;-1:-1:-1;;;;;7099:32:13;;6521:23:12;;;7081:51:13;7148:18;;;7141:34;;;6521:4:12;;:12;;7054:18:13;;6521:23:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6558:8;:6;:8::i;:::-;-1:-1:-1;;;;;6568:14:12;;;;;;;;:6;:14;;;;;;6459:124;;;;;;-1:-1:-1;6459:124:12;-1:-1:-1;6459:124:12;-1:-1:-1;6568:14:12;;-1:-1:-1;6278:312:12;-1:-1:-1;;;6278:312:12:o;4412:160::-;4463:7;4489:76;4498:36;4513:20;:18;:20::i;4498:36::-;4552:12;;4536:28;;793:22;4536:28;:::i;5608:161::-;5647:4;5670:8;;5682:1;5670:13;;:26;;;;-1:-1:-1;1796:7:7;;-1:-1:-1;;;1796:7:7;;;;5687:9:12;5670:26;:56;;;;;652:24;5700:13;2881:12:2;;;2803:97;5700:13:12;:26;5670:56;:92;;;;;5742:15;:13;:15::i;:::-;:20;;5663:99;;5608:161;:::o;5939:173::-;5996:7;6043:17;:15;:17::i;:::-;-1:-1:-1;;;;;6070:14:12;;;;;;:6;:14;;;;;;;;;6086:9;:17;;;;;;;6032:72;;;;;9019:25:13;;;;9060:18;;9053:60;;;;9129:18;;;9122:34;9172:18;;;9165:34;;;;8991:19;;6032:72:12;;;;;;;;;;;;6022:83;;;;;;6015:90;;5939:173;;;:::o;1233:57::-;1272:18;1288:2;793:22;1272:18;:::i;:::-;1233:57;:::o;5074:243::-;5142:7;1332:1;5165:5;:17;5161:44;;;5191:14;;-1:-1:-1;;;5191:14:12;;;;;;;;;;;5161:44;5222:88;-1:-1:-1;;;;;5247:31:12;5273:5;1226:1;5247:31;:::i;:::-;5280:29;5304:5;1170:1;5280:29;:::i;:::-;5222:11;:88::i;1334:530:10:-;1407:4;-1:-1:-1;;;;;1427:20:10;;;;:70;;;1481:16;1459:8;-1:-1:-1;;;;;1451:26:10;;:46;;1427:70;1423:88;;;-1:-1:-1;1506:5:10;1499:12;;1423:88;1525:25;;-1:-1:-1;;;1525:25:10;;;;;160::13;;;1525:8:10;-1:-1:-1;;;;;1525:16:10;;;;133:18:13;;1525:25:10;;;;;;;;;;;;;;;;;;-1:-1:-1;1525:25:10;;;;;;;;-1:-1:-1;;1525:25:10;;;;;;;;;;;;:::i;:::-;;;1521:138;;-1:-1:-1;1651:5:10;1644:12;;1521:138;1604:6;-1:-1:-1;;;;;1594:16:10;:6;-1:-1:-1;;;;;1594:16:10;;1590:34;;1619:5;1612:12;;;;;1590:34;-1:-1:-1;1672:25:10;;-1:-1:-1;;;1672:25:10;;-1:-1:-1;;;;;2875:32:13;;;1672:25:10;;;2857:51:13;1672:8:10;:17;;;;2830:18:13;;1672:25:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1672:25:10;;;;;;;;;;;;:::i;:::-;;;1668:190;;-1:-1:-1;1850:5:10;1843:12;;1668:190;1750:20;;:25;;;;:73;;-1:-1:-1;1787:24:10;;;;;;1779:44;;1750:73;1743:80;;;;;4933:136:12;4994:7;5020:42;1332:1;1272:18;1288:2;793:22;1272:18;:::i;:::-;5040:21;;:6;:21;:::i;2543:215:0:-;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:0;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:0;;2700:1:::1;2672:31;::::0;::::1;2857:51:13::0;2830:18;;2672:31:0::1;2688:226:13::0;2623:91:0::1;2723:28;2742:8;2723:18;:28::i;:::-;2543:215:::0;:::o;4288:118:12:-;4339:7;4365:34;4386:12;;4365:20;:34::i;6118:154::-;6191:7;6238:18;6249:6;6238:10;:18::i;:::-;6227:37;;;;;;6828:25:13;;;;6869:18;;6862:34;;;6801:18;;6227:37:12;;;;;;;;;;;;6217:48;;;;;;6210:55;;6118:154;;;;:::o;4811:116::-;4868:7;4917:3;4894:20;1378:2;4894:5;:20;:::i;:::-;:26;;;;:::i;8630:128:2:-;8714:37;8723:5;8730:7;8739:5;8746:4;8714:8;:37::i;:::-;8630:128;;;:::o;1796:162:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;735:10:5;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:5;1901:40:0;;;2857:51:13;2830:18;;1901:40:0;2688:226:13;2339:115:7;1350:19;:17;:19::i;:::-;2398:7:::1;:14:::0;;-1:-1:-1;;;;2398:14:7::1;-1:-1:-1::0;;;2398:14:7::1;::::0;;2427:20:::1;2434:12;735:10:5::0;;656:96;2434:12:7::1;2427:20;::::0;-1:-1:-1;;;;;2875:32:13;;;2857:51;;2845:2;2830:18;2427:20:7::1;2688:226:13::0;2586:117:7;1597:16;:14;:16::i;:::-;2644:7:::1;:15:::0;;-1:-1:-1;;;;2644:15:7::1;::::0;;2674:22:::1;735:10:5::0;2683:12:7::1;656:96:5::0;10321:476:2;-1:-1:-1;;;;;3561:18:2;;;10420:24;3561:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;10486:36:2;;10482:309;;;10561:5;10542:16;:24;10538:130;;;10593:60;;-1:-1:-1;;;10593:60:2;;-1:-1:-1;;;;;12415:32:13;;10593:60:2;;;12397:51:13;12464:18;;;12457:34;;;12507:18;;;12500:34;;;12370:18;;10593:60:2;12195:345:13;10538:130:2;10709:57;10718:5;10725:7;10753:5;10734:16;:24;10760:5;10709:8;:57::i;:::-;10410:387;10321:476;;;:::o;5297:300::-;-1:-1:-1;;;;;5380:18:2;;5376:86;;5421:30;;-1:-1:-1;;;5421:30:2;;5448:1;5421:30;;;2857:51:13;2830:18;;5421:30:2;2688:226:13;5376:86:2;-1:-1:-1;;;;;5475:16:2;;5471:86;;5514:32;;-1:-1:-1;;;5514:32:2;;5543:1;5514:32;;;2857:51:13;2830:18;;5514:32:2;2688:226:13;5471:86:2;5566:24;5574:4;5580:2;5584:5;5566:7;:24::i;1878:128:7:-;1796:7;;-1:-1:-1;;;1796:7:7;;;;1939:61;;;1974:15;;-1:-1:-1;;;1974:15:7;;;;;;;;;;;7362:208:2;-1:-1:-1;;;;;7432:21:2;;7428:91;;7476:32;;-1:-1:-1;;;7476:32:2;;7505:1;7476:32;;;2857:51:13;2830:18;;7476:32:2;2688:226:13;7428:91:2;7528:35;7544:1;7548:7;7557:5;7528:7;:35::i;:::-;7362:208;;:::o;5633:111:8:-;5691:7;5328:5;;;5725;;;5327:36;5322:42;;5717:20;5087:294;7296:3683;7378:14;7429:12;7443:11;7458:12;7465:1;7468;7458:6;:12::i;:::-;7428:42;;;;7552:4;7560:1;7552:9;7548:365;;7887:11;7881:3;:17;;;;;:::i;:::-;;7874:24;;;;;;7548:365;8038:4;8023:11;:19;8019:142;;8062:84;5328:5;8082:16;;5327:36;940:4:6;5322:42:8;8062:11;:84::i;:::-;8413:17;8564:11;8561:1;8558;8551:25;8956:12;8986:15;;;8971:31;;9121:22;;;;;9854:1;9835;:15;;9834:21;;10087;;;10083:25;;10072:36;10157:21;;;10153:25;;10142:36;10229:21;;;10225:25;;10214:36;10300:21;;;10296:25;;10285:36;10373:21;;;10369:25;;10358:36;10447:21;;;10443:25;;;10432:36;9363:12;;;;9359:23;;;9384:1;9355:31;8676:18;;;8666:29;;;9470:11;;;;8719:19;;;;9214:14;;;;9463:18;;;;10922:13;;-1:-1:-1;;7296:3683:8;;;;;:::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;9607:432:2:-;-1:-1:-1;;;;;9719:19:2;;9715:89;;9761:32;;-1:-1:-1;;;9761:32:2;;9790:1;9761:32;;;2857:51:13;2830:18;;9761:32:2;2688:226:13;9715:89:2;-1:-1:-1;;;;;9817:21:2;;9813:90;;9861:31;;-1:-1:-1;;;9861:31:2;;9889:1;9861:31;;;2857:51:13;2830:18;;9861:31:2;2688:226:13;9813:90:2;-1:-1:-1;;;;;9912:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;9957:76;;;;10007:7;-1:-1:-1;;;;;9991:31:2;10000:5;-1:-1:-1;;;;;9991:31:2;;10016:5;9991:31;;;;160:25:13;;148:2;133:18;;14:177;9991:31:2;;;;;;;;9607:432;;;;:::o;2078:126:7:-;1796:7;;-1:-1:-1;;;1796:7:7;;;;2136:62;;2172:15;;-1:-1:-1;;;2172:15:7;;;;;;;;;;;5912:1107:2;-1:-1:-1;;;;;6001:18:2;;5997:540;;6153:5;6137:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;5997:540:2;;-1:-1:-1;5997:540:2;;-1:-1:-1;;;;;6211:15:2;;6189:19;6211:15;;;;;;;;;;;6244:19;;;6240:115;;;6290:50;;-1:-1:-1;;;6290:50:2;;-1:-1:-1;;;;;12415:32:13;;6290:50:2;;;12397:51:13;12464:18;;;12457:34;;;12507:18;;;12500:34;;;12370:18;;6290:50:2;12195:345:13;6240:115:2;-1:-1:-1;;;;;6475:15:2;;:9;:15;;;;;;;;;;6493:19;;;;6475:37;;5997:540;-1:-1:-1;;;;;6551:16:2;;6547:425;;6714:12;:21;;;;;;;6547:425;;;-1:-1:-1;;;;;6925:13:2;;:9;:13;;;;;;;;;;:22;;;;;;6547:425;7002:2;-1:-1:-1;;;;;6987:25:2;6996:4;-1:-1:-1;;;;;6987:25:2;;7006:5;6987:25;;;;160::13;;148:2;133:18;;14:177;6987:25:2;;;;;;;;5912:1107;;;:::o;1027:550:8:-;1088:12;;-1:-1:-1;;1471:1:8;1468;1461:20;1501:9;;;;1549:11;;;1535:12;;;;1531:30;;;;;1027:550;-1:-1:-1;;1027:550:8:o;1776:194:6:-;1881:10;1875:4;1868:24;1918:4;1912;1905:18;1949:4;1943;1936:18;196:250:13;281:1;291:113;305:6;302:1;299:13;291:113;;;381:11;;;375:18;362:11;;;355:39;327:2;320:10;291:113;;;-1:-1:-1;;438:1:13;420:16;;413:27;196:250::o;451:396::-;600:2;589:9;582:21;563:4;632:6;626:13;675:6;670:2;659:9;655:18;648:34;691:79;763:6;758:2;747:9;743:18;738:2;730:6;726:15;691:79;:::i;:::-;831:2;810:15;-1:-1:-1;;806:29:13;791:45;;;;838:2;787:54;;451:396;-1:-1:-1;;451:396:13:o;1034:131::-;-1:-1:-1;;;;;1109:31:13;;1099:42;;1089:70;;1155:1;1152;1145:12;1170:367;1238:6;1246;1299:2;1287:9;1278:7;1274:23;1270:32;1267:52;;;1315:1;1312;1305:12;1267:52;1354:9;1341:23;1373:31;1398:5;1373:31;:::i;:::-;1423:5;1501:2;1486:18;;;;1473:32;;-1:-1:-1;;;1170:367:13:o;1734:508::-;1811:6;1819;1827;1880:2;1868:9;1859:7;1855:23;1851:32;1848:52;;;1896:1;1893;1886:12;1848:52;1935:9;1922:23;1954:31;1979:5;1954:31;:::i;:::-;2004:5;-1:-1:-1;2061:2:13;2046:18;;2033:32;2074:33;2033:32;2074:33;:::i;:::-;1734:508;;2126:7;;-1:-1:-1;;;2206:2:13;2191:18;;;;2178:32;;1734:508::o;2436:247::-;2495:6;2548:2;2536:9;2527:7;2523:23;2519:32;2516:52;;;2564:1;2561;2554:12;2516:52;2603:9;2590:23;2622:31;2647:5;2622:31;:::i;2919:587::-;3005:6;3013;3021;3029;3082:3;3070:9;3061:7;3057:23;3053:33;3050:53;;;3099:1;3096;3089:12;3050:53;-1:-1:-1;;3144:23:13;;;3264:2;3249:18;;3236:32;;-1:-1:-1;3367:2:13;3352:18;;3339:32;;3470:2;3455:18;3442:32;;-1:-1:-1;2919:587:13;-1:-1:-1;2919:587:13:o;3511:226::-;3570:6;3623:2;3611:9;3602:7;3598:23;3594:32;3591:52;;;3639:1;3636;3629:12;3591:52;-1:-1:-1;3684:23:13;;3511:226;-1:-1:-1;3511:226:13:o;4695:388::-;4763:6;4771;4824:2;4812:9;4803:7;4799:23;4795:32;4792:52;;;4840:1;4837;4830:12;4792:52;4879:9;4866:23;4898:31;4923:5;4898:31;:::i;:::-;4948:5;-1:-1:-1;5005:2:13;4990:18;;4977:32;5018:33;4977:32;5018:33;:::i;:::-;5070:7;5060:17;;;4695:388;;;;;:::o;5510:380::-;5589:1;5585:12;;;;5632;;;5653:61;;5707:4;5699:6;5695:17;5685:27;;5653:61;5760:2;5752:6;5749:14;5729:18;5726:38;5723:161;;5806:10;5801:3;5797:20;5794:1;5787:31;5841:4;5838:1;5831:15;5869:4;5866:1;5859:15;5895:127;5956:10;5951:3;5947:20;5944:1;5937:31;5987:4;5984:1;5977:15;6011:4;6008:1;6001:15;6027:128;6094:9;;;6115:11;;;6112:37;;;6129:18;;:::i;7186:277::-;7253:6;7306:2;7294:9;7285:7;7281:23;7277:32;7274:52;;;7322:1;7319;7312:12;7274:52;7354:9;7348:16;7407:5;7400:13;7393:21;7386:5;7383:32;7373:60;;7429:1;7426;7419:12;7468:125;7533:9;;;7554:10;;;7551:36;;;7567:18;;:::i;8261:168::-;8334:9;;;8365;;8382:15;;;8376:22;;8362:37;8352:71;;8403:18;;:::i;8434:127::-;8495:10;8490:3;8486:20;8483:1;8476:31;8526:4;8523:1;8516:15;8550:4;8547:1;8540:15;8566:217;8606:1;8632;8622:132;;8676:10;8671:3;8667:20;8664:1;8657:31;8711:4;8708:1;8701:15;8739:4;8736:1;8729:15;8622:132;-1:-1:-1;8768:9:13;;8566:217::o;9210:375::-;9298:1;9316:5;9330:249;9351:1;9341:8;9338:15;9330:249;;;9401:4;9396:3;9392:14;9386:4;9383:24;9380:50;;;9410:18;;:::i;:::-;9460:1;9450:8;9446:16;9443:49;;;9474:16;;;;9443:49;9557:1;9553:16;;;;;9513:15;;9330:249;;;9210:375;;;;;;:::o;9590:902::-;9639:5;9669:8;9659:80;;-1:-1:-1;9710:1:13;9724:5;;9659:80;9758:4;9748:76;;-1:-1:-1;9795:1:13;9809:5;;9748:76;9840:4;9858:1;9853:59;;;;9926:1;9921:174;;;;9833:262;;9853:59;9883:1;9874:10;;9897:5;;;9921:174;9958:3;9948:8;9945:17;9942:43;;;9965:18;;:::i;:::-;-1:-1:-1;;10021:1:13;10007:16;;10080:5;;9833:262;;10179:2;10169:8;10166:16;10160:3;10154:4;10151:13;10147:36;10141:2;10131:8;10128:16;10123:2;10117:4;10114:12;10110:35;10107:77;10104:203;;;-1:-1:-1;10216:19:13;;;10292:5;;10104:203;10339:42;-1:-1:-1;;10364:8:13;10358:4;10339:42;:::i;:::-;10417:6;10413:1;10409:6;10405:19;10396:7;10393:32;10390:58;;;10428:18;;:::i;:::-;10466:20;;9590:902;-1:-1:-1;;;9590:902:13:o;10497:131::-;10557:5;10586:36;10613:8;10607:4;10586:36;:::i;10633:251::-;10703:6;10756:2;10744:9;10735:7;10731:23;10727:32;10724:52;;;10772:1;10769;10762:12;10724:52;10804:9;10798:16;10823:31;10848:5;10823:31;:::i;10889:127::-;10950:10;10945:3;10941:20;10938:1;10931:31;10981:4;10978:1;10971:15;11005:4;11002:1;10995:15;11021:916;11101:6;11154:2;11142:9;11133:7;11129:23;11125:32;11122:52;;;11170:1;11167;11160:12;11122:52;11203:9;11197:16;11236:18;11228:6;11225:30;11222:50;;;11268:1;11265;11258:12;11222:50;11291:22;;11344:4;11336:13;;11332:27;-1:-1:-1;11322:55:13;;11373:1;11370;11363:12;11322:55;11406:2;11400:9;11432:18;11424:6;11421:30;11418:56;;;11454:18;;:::i;:::-;11503:2;11497:9;11595:2;11557:17;;-1:-1:-1;;11553:31:13;;;11586:2;11549:40;11545:54;11533:67;;11630:18;11615:34;;11651:22;;;11612:62;11609:88;;;11677:18;;:::i;:::-;11713:2;11706:22;11737;;;11778:15;;;11795:2;11774:24;11771:37;-1:-1:-1;11768:57:13;;;11821:1;11818;11811:12;11768:57;11834:72;11899:6;11894:2;11886:6;11882:15;11877:2;11873;11869:11;11834:72;:::i;:::-;11925:6;11021:916;-1:-1:-1;;;;;11021:916:13:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122032f17b348a9f6832b639708f91c7fa94c236cb948dd8a373be5bda41d5cedb5464736f6c634300081e0033","offset":7611}},"immutableReferences":{"4546":[{"start":1415,"length":32},{"start":4504,"length":32},{"start":4583,"length":32},{"start":4769,"length":32}],"4548":[{"start":998,"length":32},{"start":4471,"length":32}],"4788":[{"start":1552,"length":32}]},"transformations":[{"id":"4548","type":"replace","offset":998,"reason":"immutable"},{"id":"4546","type":"replace","offset":1415,"reason":"immutable"},{"id":"4788","type":"replace","offset":1552,"reason":"immutable"},{"id":"4548","type":"replace","offset":4471,"reason":"immutable"},{"id":"4546","type":"replace","offset":4504,"reason":"immutable"},{"id":"4546","type":"replace","offset":4583,"reason":"immutable"},{"id":"4546","type":"replace","offset":4769,"reason":"immutable"}],"transformationValues":{"immutables":{"4546":"0x00000000000000000000000060b9262456de011f7d15a54cdd8c48baaa8b022f","4548":"0xc4006e6e6ffaaf6996116617392beabe4f5f0a0795841322f91c2ceac34d6ace","4788":"0x000000000000000000000000d6386bdf654ddc89e66dcbba83f4c311088b2cfa"}}},"deployment":{"transactionHash":"0x95193a92fa6852520f91ecd42f4f768566790cc80c3d2b2daa56c97b150a3fbf","blockNumber":"132542324","transactionIndex":"11","deployer":"0xD6386BDF654Ddc89E66DCbba83f4C311088b2CFA"},"sources":{"contracts/PearlMiningV4.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {Math} from \"@openzeppelin/contracts/utils/math/Math.sol\";\nimport {Ownable} from \"@openzeppelin/contracts/access/Ownable.sol\";\nimport {Pausable} from \"@openzeppelin/contracts/utils/Pausable.sol\";\nimport {AgentIdGate} from \"./AgentIdGate.sol\";\n\n/// @notice Initial100 reward, -10% per20m mined; initial38 work, +50% difficulty per10%.\n/// Owner controls mining availability only. ERC20 transfers are not paused.\ncontract PearlMiningV4 is ERC20, AgentIdGate, Ownable, Pausable {\n    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 10 ** 18;\n    uint256 public constant LIQUIDITY_SUPPLY = 100_000_000 * 10 ** 18;\n    uint256 public constant MINING_SUPPLY = 900_000_000 * 10 ** 18;\n    uint256 public constant INITIAL_REWARD = 100 * 10 ** 18;\n    uint256 public constant REWARD_STEP_SUPPLY = 20_000_000 * 10 ** 18;\n    uint256 public constant MAX_REWARD_STAGE = 44;\n    uint256 public constant WORK_BITS = 38;\n    uint256 public constant WORK_TARGET = type(uint256).max >> WORK_BITS;\n    uint256 public constant DIFFICULTY_NUMERATOR = 3;\n    uint256 public constant DIFFICULTY_DENOMINATOR = 2;\n    uint256 public constant STAGE_SUPPLY = MINING_SUPPLY / 10;\n    uint256 public constant MAX_STAGE = 9;\n    uint256 public constant BURN_PERCENT = 10;\n    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;\n    bytes32 public constant PUZZLE_VERSION = keccak256(\"PEARL_INITIAL38_PROGRESS10X1P5_STEP20M_REWARD100_DEC18_NODAILYCAP_BURN10_ROUND_V4\");\n\n    address public immutable dev;\n    uint256 public startsAt;\n    bytes32 public taskSeed;\n    uint256 public successfulProofs;\n    uint256 public miningMinted;\n    mapping(bytes32 => bool) public usedProofs;\n    mapping(address => uint256) public rounds;\n    mapping(address => bytes32) public lastProof;\n\n    error MiningNotStarted();\n    error MiningAlreadyStarted();\n    error InvalidIdentity();\n    error InvalidSolution();\n    error WrongRound();\n    error ProofAlreadyUsed();\n    error RewardChanged();\n    error MiningFinished();\n    error InvalidStage();\n    error OwnershipRenunciationDisabled();\n\n    event DifficultyStageReached(uint256 stage, uint256 target, uint256 claims);\n    event MiningStarted(uint256 startsAt, bytes32 taskSeed);\n    event Mined(address indexed miner, uint256 indexed agentId, bytes32 indexed proof,\n        uint256 nonce, uint256 claimIndex, uint256 reward);\n\n    constructor(address registry_, address dev_, address initialOwner)\n        ERC20(unicode\"珍珠币\", unicode\"珍珠币\") AgentIdGate(registry_) Ownable(initialOwner)\n    {\n        require(dev_ != address(0), \"Zero dev\");\n        dev = dev_;\n        _mint(dev_, LIQUIDITY_SUPPLY);\n        _pause();\n    }\n\n    function decimals() public pure override returns (uint8) { return 18; }\n\n    function startMining() external onlyOwner {\n        if (startsAt != 0) revert MiningAlreadyStarted();\n        startsAt = block.timestamp;\n        taskSeed = keccak256(abi.encode(PUZZLE_VERSION, block.chainid, address(this),\n            blockhash(block.number - 1), startsAt));\n        _unpause();\n        emit MiningStarted(startsAt, taskSeed);\n    }\n\n    function pauseMining() external onlyOwner {\n        if (startsAt == 0) revert MiningNotStarted();\n        _pause();\n    }\n\n    function resumeMining() external onlyOwner {\n        if (startsAt == 0) revert MiningNotStarted();\n        _unpause();\n    }\n\n    /// @dev A renounced owner could permanently prevent start/resume. Use direct ownership transfer.\n    function renounceOwnership() public override onlyOwner {\n        revert OwnershipRenunciationDisabled();\n    }\n\n    function rewardStageForIssued(uint256 issued) public pure returns (uint256) {\n        return Math.min(MAX_REWARD_STAGE, issued / REWARD_STEP_SUPPLY);\n    }\n\n    /// @notice Gross issuance per proof before the blackhole split.\n    function rewardForStage(uint256 stage) public pure returns (uint256 amount) {\n        if (stage > MAX_REWARD_STAGE) revert InvalidStage();\n        amount = INITIAL_REWARD;\n        // Integer arithmetic: floor each 10% reduction, in 18-decimal units.\n        for (uint256 i; i < stage; ++i) amount = amount * 9 / 10;\n    }\n\n    function currentRewardStage() public view returns (uint256) {\n        return rewardStageForIssued(miningMinted);\n    }\n\n    function currentGrossReward() public view returns (uint256) {\n        return Math.min(rewardForStage(currentRewardStage()), MINING_SUPPLY - miningMinted);\n    }\n\n    /// @notice Net payout to the mining wallet, also quoted by challenge().\n    function currentReward() public view returns (uint256) {\n        uint256 gross = currentGrossReward();\n        return gross - _burnShare(gross);\n    }\n\n    function _burnShare(uint256 gross) private pure returns (uint256) {\n        return gross * BURN_PERCENT / 100;\n    }\n\n    function stageForIssued(uint256 issued) public pure returns (uint256) {\n        return Math.min(MAX_STAGE, issued / STAGE_SUPPLY);\n    }\n    function targetForStage(uint256 stage) public pure virtual returns (uint256) {\n        if (stage > MAX_STAGE) revert InvalidStage();\n        return Math.mulDiv(WORK_TARGET, DIFFICULTY_DENOMINATOR ** stage, DIFFICULTY_NUMERATOR ** stage);\n    }\n    function currentStage() public view returns (uint256) { return stageForIssued(miningMinted); }\n    function currentTarget() public view returns (uint256) { return targetForStage(currentStage()); }\n    function miningIssued() external view returns (uint256) { return miningMinted; }\n    function isLive() public view returns (bool) {\n        return startsAt != 0 && !paused() && totalSupply() < MAX_SUPPLY\n            && currentReward() != 0;\n    }\n\n    function publicChallenge() public view returns (bytes32) {\n        return keccak256(abi.encode(PUZZLE_VERSION, block.chainid, address(this), taskSeed));\n    }\n\n    function puzzleSeed(address wallet) public view returns (bytes32) {\n        return keccak256(abi.encode(publicChallenge(), wallet, rounds[wallet], lastProof[wallet]));\n    }\n\n    function proofDigest(address wallet, uint256 nonce) public view returns (bytes32) {\n        return keccak256(abi.encode(puzzleSeed(wallet), nonce));\n    }\n\n    function challenge(address wallet, uint256 id) external view returns (\n        bytes32 seed, uint256 target, uint256 reward, bool eligible, bool live, uint256 round\n    ) {\n        return (puzzleSeed(wallet), currentTarget(), currentReward(), this.isOwner(wallet,id),\n            isLive(), rounds[wallet]);\n    }\n\n    function mine(uint256 id, uint256 expectedRound, uint256 nonce, uint256 minReward) external whenNotPaused {\n        if (startsAt == 0) revert MiningNotStarted();\n        if (rounds[msg.sender] != expectedRound) revert WrongRound();\n        if (!this.isOwner(msg.sender,id)) revert InvalidIdentity();\n        uint256 index = successfulProofs;\n        uint256 stage = stageForIssued(miningMinted);\n        bytes32 proof = proofDigest(msg.sender,nonce);\n        if (usedProofs[proof]) revert ProofAlreadyUsed();\n        if (uint256(proof) > targetForStage(stage)) revert InvalidSolution();\n        if (miningMinted >= MINING_SUPPLY) revert MiningFinished();\n        uint256 gross = currentGrossReward();\n        uint256 burned = _burnShare(gross);\n        uint256 reward = gross - burned;\n        if (reward < minReward) revert RewardChanged();\n        usedProofs[proof] = true;\n        rounds[msg.sender] = expectedRound + 1;\n        lastProof[msg.sender] = proof;\n        successfulProofs = index + 1;\n        miningMinted += gross;\n        require(LIQUIDITY_SUPPLY + miningMinted <= MAX_SUPPLY, \"Supply cap\");\n        emit Mined(msg.sender,id,proof,nonce,index,reward);\n        uint256 nextStage = stageForIssued(miningMinted);\n        if (nextStage != stage) emit DifficultyStageReached(nextStage,targetForStage(nextStage),index + 1);\n        _mint(msg.sender, reward);\n        if (burned != 0) _mint(BURN_ADDRESS, burned);\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC20Metadata} from \"./extensions/IERC20Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {IERC20Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC-20\n * applications.\n */\nabstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {\n    mapping(address account => uint256) private _balances;\n\n    mapping(address account => mapping(address spender => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * Both values are immutable: they can only be set once during construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /// @inheritdoc IERC20\n    function totalSupply() public view virtual returns (uint256) {\n        return _totalSupply;\n    }\n\n    /// @inheritdoc IERC20\n    function balanceOf(address account) public view virtual returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `value`.\n     */\n    function transfer(address to, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, value);\n        return true;\n    }\n\n    /// @inheritdoc IERC20\n    function allowance(address owner, address spender) public view virtual returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Skips emitting an {Approval} event indicating an allowance update. This is not\n     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `value`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `value`.\n     */\n    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, value);\n        _transfer(from, to, value);\n        return true;\n    }\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _transfer(address from, address to, uint256 value) internal {\n        if (from == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        if (to == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(from, to, value);\n    }\n\n    /**\n     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\n     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\n     * this function.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _update(address from, address to, uint256 value) internal virtual {\n        if (from == address(0)) {\n            // Overflow check required: The rest of the code assumes that totalSupply never overflows\n            _totalSupply += value;\n        } else {\n            uint256 fromBalance = _balances[from];\n            if (fromBalance < value) {\n                revert ERC20InsufficientBalance(from, fromBalance, value);\n            }\n            unchecked {\n                // Overflow not possible: value <= fromBalance <= totalSupply.\n                _balances[from] = fromBalance - value;\n            }\n        }\n\n        if (to == address(0)) {\n            unchecked {\n                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\n                _totalSupply -= value;\n            }\n        } else {\n            unchecked {\n                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\n                _balances[to] += value;\n            }\n        }\n\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\n     * Relies on the `_update` mechanism\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _mint(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(address(0), account, value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\n     * Relies on the `_update` mechanism.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead\n     */\n    function _burn(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        _update(account, address(0), value);\n    }\n\n    /**\n     * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address owner, address spender, uint256 value) internal {\n        _approve(owner, spender, value, true);\n    }\n\n    /**\n     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\n     *\n     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\n     * `_spendAllowance` during the `transferFrom` operation sets the flag to false. This saves gas by not emitting any\n     * `Approval` event during `transferFrom` operations.\n     *\n     * Anyone who wishes to continue emitting `Approval` events on the `transferFrom` operation can force the flag to\n     * true using the following override:\n     *\n     * ```solidity\n     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\n     *     super._approve(owner, spender, value, true);\n     * }\n     * ```\n     *\n     * Requirements are the same as {_approve}.\n     */\n    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\n        if (owner == address(0)) {\n            revert ERC20InvalidApprover(address(0));\n        }\n        if (spender == address(0)) {\n            revert ERC20InvalidSpender(address(0));\n        }\n        _allowances[owner][spender] = value;\n        if (emitEvent) {\n            emit Approval(owner, spender, value);\n        }\n    }\n\n    /**\n     * @dev Updates `owner`'s allowance for `spender` based on spent `value`.\n     *\n     * Does not update the allowance value in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Does not emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance < type(uint256).max) {\n            if (currentAllowance < value) {\n                revert ERC20InsufficientAllowance(spender, currentAllowance, value);\n            }\n            unchecked {\n                _approve(owner, spender, currentAllowance - value, false);\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"},"@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/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)\n\npragma solidity >=0.8.4;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Return the 512-bit addition of two uint256.\n     *\n     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.\n     */\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        assembly (\"memory-safe\") {\n            low := add(a, b)\n            high := lt(low, a)\n        }\n    }\n\n    /**\n     * @dev Return the 512-bit multiplication of two uint256.\n     *\n     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.\n     */\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n        // variables such that product = high * 2²⁵⁶ + low.\n        assembly (\"memory-safe\") {\n            let mm := mulmod(a, b, not(0))\n            low := mul(a, b)\n            high := sub(sub(mm, low), lt(mm, low))\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            success = c >= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a - b;\n            success = c <= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a * b;\n            assembly (\"memory-safe\") {\n                // Only true when the multiplication doesn't overflow\n                // (c / a == b) || (a == 0)\n                success := or(eq(div(c, a), b), iszero(a))\n            }\n            // equivalent to: success ? c : 0\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `DIV` opcode returns zero when the denominator is 0.\n                result := div(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `MOD` opcode returns zero when the denominator is 0.\n                result := mod(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryAdd(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\n     */\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\n        (, uint256 result) = trySub(a, b);\n        return result;\n    }\n\n    /**\n     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryMul(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // (a + b) / 2 can overflow.\n            return (a & b) + (a ^ b) / 2;\n        }\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (high == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return low / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= high) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [high low].\n            uint256 remainder;\n            assembly (\"memory-safe\") {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                high := sub(high, gt(remainder, low))\n                low := sub(low, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly (\"memory-safe\") {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [high low] by twos.\n                low := div(low, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from high into low.\n            low |= high * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high\n            // is no longer required.\n            result = low * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n            if (high >= 1 << n) {\n                Panic.panic(Panic.UNDER_OVERFLOW);\n            }\n            return (high << (256 - n)) | (low >> n);\n        }\n    }\n\n    /**\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory buffer) private pure returns (bool) {\n        uint256 chunk;\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            // See _unsafeReadBytesOffset from utils/Bytes.sol\n            assembly (\"memory-safe\") {\n                chunk := mload(add(add(buffer, 0x20), i))\n            }\n            if (chunk >> (8 * saturatingSub(i + 0x20, buffer.length)) != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // If upper 8 bits of 16-bit half set, add 8 to result\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\n        // If upper 4 bits of 8-bit half set, add 4 to result\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\n\n        // Shifts value right by the current result and use it as an index into this lookup table:\n        //\n        // | x (4 bits) |  index  | table[index] = MSB position |\n        // |------------|---------|-----------------------------|\n        // |    0000    |    0    |        table[0] = 0         |\n        // |    0001    |    1    |        table[1] = 0         |\n        // |    0010    |    2    |        table[2] = 1         |\n        // |    0011    |    3    |        table[3] = 1         |\n        // |    0100    |    4    |        table[4] = 2         |\n        // |    0101    |    5    |        table[5] = 2         |\n        // |    0110    |    6    |        table[6] = 2         |\n        // |    0111    |    7    |        table[7] = 2         |\n        // |    1000    |    8    |        table[8] = 3         |\n        // |    1001    |    9    |        table[9] = 3         |\n        // |    1010    |   10    |        table[10] = 3        |\n        // |    1011    |   11    |        table[11] = 3        |\n        // |    1100    |   12    |        table[12] = 3        |\n        // |    1101    |   13    |        table[13] = 3        |\n        // |    1110    |   14    |        table[14] = 3        |\n        // |    1111    |   15    |        table[15] = 3        |\n        //\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the first 16 bytes (most significant half).\n        assembly (\"memory-safe\") {\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits in a uint256.\n     */\n    function clz(uint256 x) internal pure returns (uint256) {\n        return ternary(x == 0, 256, 255 - log2(x));\n    }\n}\n"},"@openzeppelin/contracts/utils/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/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/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/Pausable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/Pausable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n    bool private _paused;\n\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    /**\n     * @dev The operation failed because the contract is paused.\n     */\n    error EnforcedPause();\n\n    /**\n     * @dev The operation failed because the contract is not paused.\n     */\n    error ExpectedPause();\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        if (paused()) {\n            revert EnforcedPause();\n        }\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        if (!paused()) {\n            revert ExpectedPause();\n        }\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n}\n"},"contracts/AgentIdGate.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IAgentIdentity} from \"./IAgentIdentity.sol\";\n\ninterface IAgentRegistry {\n    function ownerOf(uint256 id) external view returns (address);\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @dev ABI and handle hashing verified against recompiled HandleRegistry mainnet runtime.\n/// Mainnet deployment is pinned to the reviewed registry; test chains may use explicit fixtures.\n/// Raw handles are hashed unchanged: never append/remove a display '.ai' suffix.\ncontract AgentIdGate is IAgentIdentity {\n    address public constant BSC_MAINNET_REGISTRY = 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F;\n    bytes32 public constant BSC_MAINNET_CODE_HASH = 0xc4006e6e6ffaaf6996116617392beabe4f5f0a0795841322f91c2ceac34d6ace;\n    IAgentRegistry public immutable registry;\n    bytes32 public immutable registryCodeHash;\n    constructor(address registry_) {\n        require(registry_.code.length > 0, \"Registry has no code\");\n        if (block.chainid == 56) {\n            require(registry_ == BSC_MAINNET_REGISTRY, \"Not reviewed BSC registry\");\n            require(registry_.codehash == BSC_MAINNET_CODE_HASH, \"Registry code changed\");\n        }\n        registry = IAgentRegistry(registry_);\n        registryCodeHash = registry_.codehash;\n    }\n    function isOwner(address wallet, uint256 agentId) external view returns (bool) {\n        if (wallet == address(0) || address(registry).codehash != registryCodeHash) return false;\n        try registry.ownerOf(agentId) returns (address holder) {\n            if (holder != wallet) return false;\n        } catch { return false; }\n        try registry.handleOf(wallet) returns (string memory handle) {\n            return bytes(handle).length != 0 && uint256(keccak256(bytes(handle))) == agentId;\n        } catch { return false; }\n    }\n}\n"},"contracts/IAgentIdentity.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\n/// @notice Adapter isolates the official registry ABI from mining policy.\ninterface IAgentIdentity {\n    function isOwner(address wallet, uint256 agentId) external view returns (bool);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.30+commit.73712a01","compilerSettings":{"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris"},"name":"PearlMiningV4","fullyQualifiedName":"contracts/PearlMiningV4.sol:PearlMiningV4"},"abi":[{"type":"constructor","inputs":[{"name":"registry_","type":"address","internalType":"address"},{"name":"dev_","type":"address","internalType":"address"},{"name":"initialOwner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ERC20InsufficientAllowance","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"allowance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InsufficientBalance","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSpender","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"}]},{"name":"EnforcedPause","type":"error","inputs":[]},{"name":"ExpectedPause","type":"error","inputs":[]},{"name":"InvalidIdentity","type":"error","inputs":[]},{"name":"InvalidSolution","type":"error","inputs":[]},{"name":"InvalidStage","type":"error","inputs":[]},{"name":"MiningAlreadyStarted","type":"error","inputs":[]},{"name":"MiningFinished","type":"error","inputs":[]},{"name":"MiningNotStarted","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":"OwnershipRenunciationDisabled","type":"error","inputs":[]},{"name":"ProofAlreadyUsed","type":"error","inputs":[]},{"name":"RewardChanged","type":"error","inputs":[]},{"name":"WrongRound","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DifficultyStageReached","type":"event","inputs":[{"name":"stage","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"target","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"claims","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Mined","type":"event","inputs":[{"name":"miner","type":"address","indexed":true,"internalType":"address"},{"name":"agentId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"proof","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"nonce","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"claimIndex","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"reward","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MiningStarted","type":"event","inputs":[{"name":"startsAt","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"taskSeed","type":"bytes32","indexed":false,"internalType":"bytes32"}],"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":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"BSC_MAINNET_CODE_HASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"BSC_MAINNET_REGISTRY","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"BURN_ADDRESS","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"BURN_PERCENT","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DIFFICULTY_DENOMINATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DIFFICULTY_NUMERATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"INITIAL_REWARD","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"LIQUIDITY_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_REWARD_STAGE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_STAGE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MINING_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PUZZLE_VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"REWARD_STEP_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"STAGE_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"WORK_BITS","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"WORK_TARGET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"challenge","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"seed","type":"bytes32","internalType":"bytes32"},{"name":"target","type":"uint256","internalType":"uint256"},{"name":"reward","type":"uint256","internalType":"uint256"},{"name":"eligible","type":"bool","internalType":"bool"},{"name":"live","type":"bool","internalType":"bool"},{"name":"round","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentGrossReward","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentReward","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentRewardStage","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentStage","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentTarget","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"pure"},{"name":"dev","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"isLive","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isOwner","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"agentId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"lastProof","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"mine","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"},{"name":"expectedRound","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"minReward","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"miningIssued","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"miningMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pauseMining","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"proofDigest","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"nonce","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"publicChallenge","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"puzzleSeed","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"registry","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IAgentRegistry"}],"stateMutability":"view"},{"name":"registryCodeHash","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"resumeMining","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"rewardForStage","type":"function","inputs":[{"name":"stage","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"rewardStageForIssued","type":"function","inputs":[{"name":"issued","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"rounds","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"stageForIssued","type":"function","inputs":[{"name":"issued","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"startMining","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"startsAt","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"successfulProofs","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"targetForStage","type":"function","inputs":[{"name":"stage","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"taskSeed","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"usedProofs","type":"function","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"registry_","type":"address"},{"internalType":"address","name":"dev_","type":"address"},{"internalType":"address","name":"initialOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"InvalidIdentity","type":"error"},{"inputs":[],"name":"InvalidSolution","type":"error"},{"inputs":[],"name":"InvalidStage","type":"error"},{"inputs":[],"name":"MiningAlreadyStarted","type":"error"},{"inputs":[],"name":"MiningFinished","type":"error"},{"inputs":[],"name":"MiningNotStarted","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":"OwnershipRenunciationDisabled","type":"error"},{"inputs":[],"name":"ProofAlreadyUsed","type":"error"},{"inputs":[],"name":"RewardChanged","type":"error"},{"inputs":[],"name":"WrongRound","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"stage","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"target","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claims","type":"uint256"}],"name":"DifficultyStageReached","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"miner","type":"address"},{"indexed":true,"internalType":"uint256","name":"agentId","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"proof","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claimIndex","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"Mined","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startsAt","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"taskSeed","type":"bytes32"}],"name":"MiningStarted","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":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"BSC_MAINNET_CODE_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BSC_MAINNET_REGISTRY","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BURN_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BURN_PERCENT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DIFFICULTY_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DIFFICULTY_NUMERATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INITIAL_REWARD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LIQUIDITY_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_REWARD_STAGE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_STAGE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINING_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PUZZLE_VERSION","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REWARD_STEP_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"STAGE_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WORK_BITS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WORK_TARGET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"challenge","outputs":[{"internalType":"bytes32","name":"seed","type":"bytes32"},{"internalType":"uint256","name":"target","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"bool","name":"eligible","type":"bool"},{"internalType":"bool","name":"live","type":"bool"},{"internalType":"uint256","name":"round","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentGrossReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRewardStage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentStage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentTarget","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"dev","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isLive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"agentId","type":"uint256"}],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastProof","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"expectedRound","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"minReward","type":"uint256"}],"name":"mine","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"miningIssued","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"miningMinted","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":[],"name":"pauseMining","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"proofDigest","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicChallenge","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"puzzleSeed","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"registry","outputs":[{"internalType":"contract IAgentRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"registryCodeHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resumeMining","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"stage","type":"uint256"}],"name":"rewardForStage","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"issued","type":"uint256"}],"name":"rewardStageForIssued","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rounds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"issued","type":"uint256"}],"name":"stageForIssued","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"startMining","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startsAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"successfulProofs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"stage","type":"uint256"}],"name":"targetForStage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"taskSeed","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"usedProofs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}],"devdoc":{"errors":{"ERC20InsufficientAllowance(address,uint256,uint256)":[{"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers.","params":{"allowance":"Amount of tokens a `spender` is allowed to operate with.","needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner."}}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers.","params":{"balance":"Current balance for the interacting account.","needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred."}}],"ERC20InvalidApprover(address)":[{"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals.","params":{"approver":"Address initiating an approval operation."}}],"ERC20InvalidReceiver(address)":[{"details":"Indicates a failure with the token `receiver`. Used in transfers.","params":{"receiver":"Address to which tokens are being transferred."}}],"ERC20InvalidSender(address)":[{"details":"Indicates a failure with the token `sender`. Used in transfers.","params":{"sender":"Address whose tokens are being transferred."}}],"ERC20InvalidSpender(address)":[{"details":"Indicates a failure with the `spender` to be approved. Used in approvals.","params":{"spender":"Address that may be allowed to operate on tokens without being their owner."}}],"EnforcedPause()":[{"details":"The operation failed because the contract is paused."}],"ExpectedPause()":[{"details":"The operation failed because the contract is not paused."}],"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 the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."}},"kind":"dev","methods":{"allowance(address,address)":{"details":"Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"balanceOf(address)":{"details":"Returns the value of tokens owned by `account`."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"renounceOwnership()":{"details":"A renounced owner could permanently prevent start/resume. Use direct ownership transfer."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"Returns the value of tokens in existence."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"userdoc":{"kind":"user","methods":{"currentReward()":{"notice":"Net payout to the mining wallet, also quoted by challenge()."},"rewardForStage(uint256)":{"notice":"Gross issuance per proof before the blackhole split."}},"notice":"Initial100 reward, -10% per20m mined; initial38 work, +50% difficulty per10%. Owner controls mining availability only. ERC20 transfers are not paused.","version":1}},"settings":{"compilationTarget":{"contracts/PearlMiningV4.sol":"PearlMiningV4"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"@openzeppelin/contracts/access/Ownable.sol":{"keccak256":"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb","license":"MIT","urls":["bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6","dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a"]},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"keccak256":"0x1b88b3fb3d85ba5496d7d5f396f83ee1fddcdd6762059ff65992655b67920998","license":"MIT","urls":["bzz-raw://89393bb3212da1c0889601b9706a07b39419ddc4d2faab9eaf6e7f9152cf6a1c","dweb:/ipfs/QmcCfzzxv1Bkdz1c1yF4gQCeYb6Us5BJANnzTFqawfd1HL"]},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"keccak256":"0x669464167428061ee0f8618b73b3ee90aff8405683e7ddde8cd77dadaa1afe29","license":"MIT","urls":["bzz-raw://0dda78587a7358b4fdf6b9fca0fde5a5e34930f36d5268a16028627fc0170195","dweb:/ipfs/QmQ1b6cCceDRWNxti9HifsTCzmVP25Haxs1bWugm52vTqH"]},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2","license":"MIT","urls":["bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303","dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV"]},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f","license":"MIT","urls":["bzz-raw://f95ee0bbd4dd3ac730d066ba3e785ded4565e890dbec2fa7d3b9fe3bad9d0d6e","dweb:/ipfs/QmSLr6bHkPFWT7ntj34jmwfyskpwo97T9jZUrk5sz3sdtR"]},"@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/Pausable.sol":{"keccak256":"0xdb484371dfbb848cb6f5d70464e9ac9b2900e4164ead76bbce4fef0b44bcc68f","license":"MIT","urls":["bzz-raw://f9d6f6f6600a2bec622f699081b58350873b5e63ce05464d17d674a290bb8a7c","dweb:/ipfs/QmQKVzSQY1PM3Bid4QhgVVZyx6B4Jx7XgaQzLKHj38vJz8"]},"@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"]},"contracts/AgentIdGate.sol":{"keccak256":"0x3a66b322d0518dd7bf89d40a50c7b4c494e3594dd0909108572f366b2c8e8c8f","license":"MIT","urls":["bzz-raw://bfe2f204c557d917db9794555a9f070ec716654723173dadc054932953b09d56","dweb:/ipfs/QmeA2DPfkuE95LQrwnG8ptUycfwkHWQDeXobCa4vgakCyD"]},"contracts/IAgentIdentity.sol":{"keccak256":"0x675b12455cbc0f974b52c32dde0c30621fd0b139457d9ddbe8a4b8ff07224f7e","license":"MIT","urls":["bzz-raw://17001a66b4c091de196004bc3dd08eaf543e54af0740c8cebb01fd62365bee2c","dweb:/ipfs/QmQuU3AGzf3Fsg42f77wb9XD5TvPkhxQvDiKbpPMPR2qhC"]},"contracts/PearlMiningV4.sol":{"keccak256":"0xa8fa2347186e820e515f96a7ce9c7d586fbde4e9c5a55e6640c3bb83ace0c0f1","license":"MIT","urls":["bzz-raw://256cf4d0fd3ece66569c92e8571f624edcf96a301fd94a049a3a810be035f49d","dweb:/ipfs/QmY8XrEATQ6i6KxJVpJbbkcZWjW4bhf411Dem9LyRmcWea"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_bytes32,t_bool)":{"key":"t_bytes32","label":"mapping(bytes32 => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_bytes32)":{"key":"t_address","label":"mapping(address => bytes32)","value":"t_bytes32","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":307,"label":"_balances","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":313,"label":"_allowances","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"2","type":"t_uint256","astId":315,"label":"_totalSupply","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"3","type":"t_string_storage","astId":317,"label":"_name","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"4","type":"t_string_storage","astId":319,"label":"_symbol","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"5","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"5","type":"t_bool","astId":994,"label":"_paused","offset":20,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"6","type":"t_uint256","astId":4790,"label":"startsAt","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"7","type":"t_bytes32","astId":4792,"label":"taskSeed","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"8","type":"t_uint256","astId":4794,"label":"successfulProofs","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"9","type":"t_uint256","astId":4796,"label":"miningMinted","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"10","type":"t_mapping(t_bytes32,t_bool)","astId":4800,"label":"usedProofs","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"11","type":"t_mapping(t_address,t_uint256)","astId":4804,"label":"rounds","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"12","type":"t_mapping(t_address,t_bytes32)","astId":4808,"label":"lastProof","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Initial100 reward, -10% per20m mined; initial38 work, +50% difficulty per10%. Owner controls mining availability only. ERC20 transfers are not paused.","methods":{"currentReward()":{"notice":"Net payout to the mining wallet, also quoted by challenge()."},"rewardForStage(uint256)":{"notice":"Gross issuance per proof before the blackhole split."}},"version":1},"devdoc":{"kind":"dev","errors":{"EnforcedPause()":[{"details":"The operation failed because the contract is paused."}],"ExpectedPause()":[{"details":"The operation failed because the contract is not paused."}],"ERC20InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC20InvalidSpender(address)":[{"params":{"spender":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `spender` to be approved. Used in approvals."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"ERC20InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC20InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred.","balance":"Current balance for the interacting account."},"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers."}],"ERC20InsufficientAllowance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner.","allowance":"Amount of tokens a `spender` is allowed to operate with."},"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers."}]},"events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."},"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"Returns the value of tokens in existence."},"balanceOf(address)":{"details":"Returns the value of tokens owned by `account`."},"renounceOwnership()":{"details":"A renounced owner could permanently prevent start/resume. Use direct ownership transfer."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"allowance(address,address)":{"details":"Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."}},"version":1},"sourceIds":{"contracts/AgentIdGate.sol":{"id":10},"contracts/PearlMiningV4.sol":{"id":12},"contracts/IAgentIdentity.sol":{"id":11},"@openzeppelin/contracts/utils/Panic.sol":{"id":6},"@openzeppelin/contracts/utils/Context.sol":{"id":5},"@openzeppelin/contracts/access/Ownable.sol":{"id":0},"@openzeppelin/contracts/utils/Pausable.sol":{"id":7},"@openzeppelin/contracts/utils/math/Math.sol":{"id":8},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":3},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"id":9},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":1},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":4}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/AgentIdGate.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IAgentIdentity} from \"./IAgentIdentity.sol\";\n\ninterface IAgentRegistry {\n    function ownerOf(uint256 id) external view returns (address);\n    function handleOf(address wallet) external view returns (string memory);\n}\n\n/// @dev ABI and handle hashing verified against recompiled HandleRegistry mainnet runtime.\n/// Mainnet deployment is pinned to the reviewed registry; test chains may use explicit fixtures.\n/// Raw handles are hashed unchanged: never append/remove a display '.ai' suffix.\ncontract AgentIdGate is IAgentIdentity {\n    address public constant BSC_MAINNET_REGISTRY = 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F;\n    bytes32 public constant BSC_MAINNET_CODE_HASH = 0xc4006e6e6ffaaf6996116617392beabe4f5f0a0795841322f91c2ceac34d6ace;\n    IAgentRegistry public immutable registry;\n    bytes32 public immutable registryCodeHash;\n    constructor(address registry_) {\n        require(registry_.code.length > 0, \"Registry has no code\");\n        if (block.chainid == 56) {\n            require(registry_ == BSC_MAINNET_REGISTRY, \"Not reviewed BSC registry\");\n            require(registry_.codehash == BSC_MAINNET_CODE_HASH, \"Registry code changed\");\n        }\n        registry = IAgentRegistry(registry_);\n        registryCodeHash = registry_.codehash;\n    }\n    function isOwner(address wallet, uint256 agentId) external view returns (bool) {\n        if (wallet == address(0) || address(registry).codehash != registryCodeHash) return false;\n        try registry.ownerOf(agentId) returns (address holder) {\n            if (holder != wallet) return false;\n        } catch { return false; }\n        try registry.handleOf(wallet) returns (string memory handle) {\n            return bytes(handle).length != 0 && uint256(keccak256(bytes(handle))) == agentId;\n        } catch { return false; }\n    }\n}\n"},"contracts/PearlMiningV4.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {Math} from \"@openzeppelin/contracts/utils/math/Math.sol\";\nimport {Ownable} from \"@openzeppelin/contracts/access/Ownable.sol\";\nimport {Pausable} from \"@openzeppelin/contracts/utils/Pausable.sol\";\nimport {AgentIdGate} from \"./AgentIdGate.sol\";\n\n/// @notice Initial100 reward, -10% per20m mined; initial38 work, +50% difficulty per10%.\n/// Owner controls mining availability only. ERC20 transfers are not paused.\ncontract PearlMiningV4 is ERC20, AgentIdGate, Ownable, Pausable {\n    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 10 ** 18;\n    uint256 public constant LIQUIDITY_SUPPLY = 100_000_000 * 10 ** 18;\n    uint256 public constant MINING_SUPPLY = 900_000_000 * 10 ** 18;\n    uint256 public constant INITIAL_REWARD = 100 * 10 ** 18;\n    uint256 public constant REWARD_STEP_SUPPLY = 20_000_000 * 10 ** 18;\n    uint256 public constant MAX_REWARD_STAGE = 44;\n    uint256 public constant WORK_BITS = 38;\n    uint256 public constant WORK_TARGET = type(uint256).max >> WORK_BITS;\n    uint256 public constant DIFFICULTY_NUMERATOR = 3;\n    uint256 public constant DIFFICULTY_DENOMINATOR = 2;\n    uint256 public constant STAGE_SUPPLY = MINING_SUPPLY / 10;\n    uint256 public constant MAX_STAGE = 9;\n    uint256 public constant BURN_PERCENT = 10;\n    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;\n    bytes32 public constant PUZZLE_VERSION = keccak256(\"PEARL_INITIAL38_PROGRESS10X1P5_STEP20M_REWARD100_DEC18_NODAILYCAP_BURN10_ROUND_V4\");\n\n    address public immutable dev;\n    uint256 public startsAt;\n    bytes32 public taskSeed;\n    uint256 public successfulProofs;\n    uint256 public miningMinted;\n    mapping(bytes32 => bool) public usedProofs;\n    mapping(address => uint256) public rounds;\n    mapping(address => bytes32) public lastProof;\n\n    error MiningNotStarted();\n    error MiningAlreadyStarted();\n    error InvalidIdentity();\n    error InvalidSolution();\n    error WrongRound();\n    error ProofAlreadyUsed();\n    error RewardChanged();\n    error MiningFinished();\n    error InvalidStage();\n    error OwnershipRenunciationDisabled();\n\n    event DifficultyStageReached(uint256 stage, uint256 target, uint256 claims);\n    event MiningStarted(uint256 startsAt, bytes32 taskSeed);\n    event Mined(address indexed miner, uint256 indexed agentId, bytes32 indexed proof,\n        uint256 nonce, uint256 claimIndex, uint256 reward);\n\n    constructor(address registry_, address dev_, address initialOwner)\n        ERC20(unicode\"珍珠币\", unicode\"珍珠币\") AgentIdGate(registry_) Ownable(initialOwner)\n    {\n        require(dev_ != address(0), \"Zero dev\");\n        dev = dev_;\n        _mint(dev_, LIQUIDITY_SUPPLY);\n        _pause();\n    }\n\n    function decimals() public pure override returns (uint8) { return 18; }\n\n    function startMining() external onlyOwner {\n        if (startsAt != 0) revert MiningAlreadyStarted();\n        startsAt = block.timestamp;\n        taskSeed = keccak256(abi.encode(PUZZLE_VERSION, block.chainid, address(this),\n            blockhash(block.number - 1), startsAt));\n        _unpause();\n        emit MiningStarted(startsAt, taskSeed);\n    }\n\n    function pauseMining() external onlyOwner {\n        if (startsAt == 0) revert MiningNotStarted();\n        _pause();\n    }\n\n    function resumeMining() external onlyOwner {\n        if (startsAt == 0) revert MiningNotStarted();\n        _unpause();\n    }\n\n    /// @dev A renounced owner could permanently prevent start/resume. Use direct ownership transfer.\n    function renounceOwnership() public override onlyOwner {\n        revert OwnershipRenunciationDisabled();\n    }\n\n    function rewardStageForIssued(uint256 issued) public pure returns (uint256) {\n        return Math.min(MAX_REWARD_STAGE, issued / REWARD_STEP_SUPPLY);\n    }\n\n    /// @notice Gross issuance per proof before the blackhole split.\n    function rewardForStage(uint256 stage) public pure returns (uint256 amount) {\n        if (stage > MAX_REWARD_STAGE) revert InvalidStage();\n        amount = INITIAL_REWARD;\n        // Integer arithmetic: floor each 10% reduction, in 18-decimal units.\n        for (uint256 i; i < stage; ++i) amount = amount * 9 / 10;\n    }\n\n    function currentRewardStage() public view returns (uint256) {\n        return rewardStageForIssued(miningMinted);\n    }\n\n    function currentGrossReward() public view returns (uint256) {\n        return Math.min(rewardForStage(currentRewardStage()), MINING_SUPPLY - miningMinted);\n    }\n\n    /// @notice Net payout to the mining wallet, also quoted by challenge().\n    function currentReward() public view returns (uint256) {\n        uint256 gross = currentGrossReward();\n        return gross - _burnShare(gross);\n    }\n\n    function _burnShare(uint256 gross) private pure returns (uint256) {\n        return gross * BURN_PERCENT / 100;\n    }\n\n    function stageForIssued(uint256 issued) public pure returns (uint256) {\n        return Math.min(MAX_STAGE, issued / STAGE_SUPPLY);\n    }\n    function targetForStage(uint256 stage) public pure virtual returns (uint256) {\n        if (stage > MAX_STAGE) revert InvalidStage();\n        return Math.mulDiv(WORK_TARGET, DIFFICULTY_DENOMINATOR ** stage, DIFFICULTY_NUMERATOR ** stage);\n    }\n    function currentStage() public view returns (uint256) { return stageForIssued(miningMinted); }\n    function currentTarget() public view returns (uint256) { return targetForStage(currentStage()); }\n    function miningIssued() external view returns (uint256) { return miningMinted; }\n    function isLive() public view returns (bool) {\n        return startsAt != 0 && !paused() && totalSupply() < MAX_SUPPLY\n            && currentReward() != 0;\n    }\n\n    function publicChallenge() public view returns (bytes32) {\n        return keccak256(abi.encode(PUZZLE_VERSION, block.chainid, address(this), taskSeed));\n    }\n\n    function puzzleSeed(address wallet) public view returns (bytes32) {\n        return keccak256(abi.encode(publicChallenge(), wallet, rounds[wallet], lastProof[wallet]));\n    }\n\n    function proofDigest(address wallet, uint256 nonce) public view returns (bytes32) {\n        return keccak256(abi.encode(puzzleSeed(wallet), nonce));\n    }\n\n    function challenge(address wallet, uint256 id) external view returns (\n        bytes32 seed, uint256 target, uint256 reward, bool eligible, bool live, uint256 round\n    ) {\n        return (puzzleSeed(wallet), currentTarget(), currentReward(), this.isOwner(wallet,id),\n            isLive(), rounds[wallet]);\n    }\n\n    function mine(uint256 id, uint256 expectedRound, uint256 nonce, uint256 minReward) external whenNotPaused {\n        if (startsAt == 0) revert MiningNotStarted();\n        if (rounds[msg.sender] != expectedRound) revert WrongRound();\n        if (!this.isOwner(msg.sender,id)) revert InvalidIdentity();\n        uint256 index = successfulProofs;\n        uint256 stage = stageForIssued(miningMinted);\n        bytes32 proof = proofDigest(msg.sender,nonce);\n        if (usedProofs[proof]) revert ProofAlreadyUsed();\n        if (uint256(proof) > targetForStage(stage)) revert InvalidSolution();\n        if (miningMinted >= MINING_SUPPLY) revert MiningFinished();\n        uint256 gross = currentGrossReward();\n        uint256 burned = _burnShare(gross);\n        uint256 reward = gross - burned;\n        if (reward < minReward) revert RewardChanged();\n        usedProofs[proof] = true;\n        rounds[msg.sender] = expectedRound + 1;\n        lastProof[msg.sender] = proof;\n        successfulProofs = index + 1;\n        miningMinted += gross;\n        require(LIQUIDITY_SUPPLY + miningMinted <= MAX_SUPPLY, \"Supply cap\");\n        emit Mined(msg.sender,id,proof,nonce,index,reward);\n        uint256 nextStage = stageForIssued(miningMinted);\n        if (nextStage != stage) emit DifficultyStageReached(nextStage,targetForStage(nextStage),index + 1);\n        _mint(msg.sender, reward);\n        if (burned != 0) _mint(BURN_ADDRESS, burned);\n    }\n}\n"},"contracts/IAgentIdentity.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\n/// @notice Adapter isolates the official registry ABI from mining policy.\ninterface IAgentIdentity {\n    function isOwner(address wallet, uint256 agentId) external view returns (bool);\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/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/Pausable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/Pausable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n    bool private _paused;\n\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    /**\n     * @dev The operation failed because the contract is paused.\n     */\n    error EnforcedPause();\n\n    /**\n     * @dev The operation failed because the contract is not paused.\n     */\n    error ExpectedPause();\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        if (paused()) {\n            revert EnforcedPause();\n        }\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        if (!paused()) {\n            revert ExpectedPause();\n        }\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n}\n"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.6.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Return the 512-bit addition of two uint256.\n     *\n     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.\n     */\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        assembly (\"memory-safe\") {\n            low := add(a, b)\n            high := lt(low, a)\n        }\n    }\n\n    /**\n     * @dev Return the 512-bit multiplication of two uint256.\n     *\n     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.\n     */\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n        // variables such that product = high * 2²⁵⁶ + low.\n        assembly (\"memory-safe\") {\n            let mm := mulmod(a, b, not(0))\n            low := mul(a, b)\n            high := sub(sub(mm, low), lt(mm, low))\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            success = c >= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a - b;\n            success = c <= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a * b;\n            assembly (\"memory-safe\") {\n                // Only true when the multiplication doesn't overflow\n                // (c / a == b) || (a == 0)\n                success := or(eq(div(c, a), b), iszero(a))\n            }\n            // equivalent to: success ? c : 0\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `DIV` opcode returns zero when the denominator is 0.\n                result := div(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `MOD` opcode returns zero when the denominator is 0.\n                result := mod(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryAdd(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\n     */\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\n        (, uint256 result) = trySub(a, b);\n        return result;\n    }\n\n    /**\n     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryMul(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // (a + b) / 2 can overflow.\n            return (a & b) + (a ^ b) / 2;\n        }\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (high == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return low / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= high) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [high low].\n            uint256 remainder;\n            assembly (\"memory-safe\") {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                high := sub(high, gt(remainder, low))\n                low := sub(low, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly (\"memory-safe\") {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [high low] by twos.\n                low := div(low, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from high into low.\n            low |= high * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high\n            // is no longer required.\n            result = low * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n            if (high >= 1 << n) {\n                Panic.panic(Panic.UNDER_OVERFLOW);\n            }\n            return (high << (256 - n)) | (low >> n);\n        }\n    }\n\n    /**\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory buffer) private pure returns (bool) {\n        uint256 chunk;\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            // See _unsafeReadBytesOffset from utils/Bytes.sol\n            assembly (\"memory-safe\") {\n                chunk := mload(add(add(buffer, 0x20), i))\n            }\n            if (chunk >> (8 * saturatingSub(i + 0x20, buffer.length)) != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // If upper 8 bits of 16-bit half set, add 8 to result\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\n        // If upper 4 bits of 8-bit half set, add 4 to result\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\n\n        // Shifts value right by the current result and use it as an index into this lookup table:\n        //\n        // | x (4 bits) |  index  | table[index] = MSB position |\n        // |------------|---------|-----------------------------|\n        // |    0000    |    0    |        table[0] = 0         |\n        // |    0001    |    1    |        table[1] = 0         |\n        // |    0010    |    2    |        table[2] = 1         |\n        // |    0011    |    3    |        table[3] = 1         |\n        // |    0100    |    4    |        table[4] = 2         |\n        // |    0101    |    5    |        table[5] = 2         |\n        // |    0110    |    6    |        table[6] = 2         |\n        // |    0111    |    7    |        table[7] = 2         |\n        // |    1000    |    8    |        table[8] = 3         |\n        // |    1001    |    9    |        table[9] = 3         |\n        // |    1010    |   10    |        table[10] = 3        |\n        // |    1011    |   11    |        table[11] = 3        |\n        // |    1100    |   12    |        table[12] = 3        |\n        // |    1101    |   13    |        table[13] = 3        |\n        // |    1110    |   14    |        table[14] = 3        |\n        // |    1111    |   15    |        table[15] = 3        |\n        //\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the first 16 bytes (most significant half).\n        assembly (\"memory-safe\") {\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits in a uint256.\n     */\n    function clz(uint256 x) internal pure returns (uint256) {\n        return ternary(x == 0, 256, 255 - log2(x));\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC20Metadata} from \"./extensions/IERC20Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {IERC20Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC-20\n * applications.\n */\nabstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {\n    mapping(address account => uint256) private _balances;\n\n    mapping(address account => mapping(address spender => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * Both values are immutable: they can only be set once during construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /// @inheritdoc IERC20\n    function totalSupply() public view virtual returns (uint256) {\n        return _totalSupply;\n    }\n\n    /// @inheritdoc IERC20\n    function balanceOf(address account) public view virtual returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `value`.\n     */\n    function transfer(address to, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, value);\n        return true;\n    }\n\n    /// @inheritdoc IERC20\n    function allowance(address owner, address spender) public view virtual returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Skips emitting an {Approval} event indicating an allowance update. This is not\n     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `value`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `value`.\n     */\n    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, value);\n        _transfer(from, to, value);\n        return true;\n    }\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _transfer(address from, address to, uint256 value) internal {\n        if (from == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        if (to == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(from, to, value);\n    }\n\n    /**\n     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\n     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\n     * this function.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _update(address from, address to, uint256 value) internal virtual {\n        if (from == address(0)) {\n            // Overflow check required: The rest of the code assumes that totalSupply never overflows\n            _totalSupply += value;\n        } else {\n            uint256 fromBalance = _balances[from];\n            if (fromBalance < value) {\n                revert ERC20InsufficientBalance(from, fromBalance, value);\n            }\n            unchecked {\n                // Overflow not possible: value <= fromBalance <= totalSupply.\n                _balances[from] = fromBalance - value;\n            }\n        }\n\n        if (to == address(0)) {\n            unchecked {\n                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\n                _totalSupply -= value;\n            }\n        } else {\n            unchecked {\n                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\n                _balances[to] += value;\n            }\n        }\n\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\n     * Relies on the `_update` mechanism\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _mint(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(address(0), account, value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\n     * Relies on the `_update` mechanism.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead\n     */\n    function _burn(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        _update(account, address(0), value);\n    }\n\n    /**\n     * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address owner, address spender, uint256 value) internal {\n        _approve(owner, spender, value, true);\n    }\n\n    /**\n     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\n     *\n     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\n     * `_spendAllowance` during the `transferFrom` operation sets the flag to false. This saves gas by not emitting any\n     * `Approval` event during `transferFrom` operations.\n     *\n     * Anyone who wishes to continue emitting `Approval` events on the `transferFrom` operation can force the flag to\n     * true using the following override:\n     *\n     * ```solidity\n     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\n     *     super._approve(owner, spender, value, true);\n     * }\n     * ```\n     *\n     * Requirements are the same as {_approve}.\n     */\n    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\n        if (owner == address(0)) {\n            revert ERC20InvalidApprover(address(0));\n        }\n        if (spender == address(0)) {\n            revert ERC20InvalidSpender(address(0));\n        }\n        _allowances[owner][spender] = value;\n        if (emitEvent) {\n            emit Approval(owner, spender, value);\n        }\n    }\n\n    /**\n     * @dev Updates `owner`'s allowance for `spender` based on spent `value`.\n     *\n     * Does not update the allowance value in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Does not emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance < type(uint256).max) {\n            if (currentAllowance < value) {\n                revert ERC20InsufficientAllowance(spender, currentAllowance, value);\n            }\n            unchecked {\n                _approve(owner, spender, currentAllowance - value, false);\n            }\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\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/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/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"}},"language":"Solidity","settings":{"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris"}},"stdJsonOutput":{"sources":{"contracts/AgentIdGate.sol":{"id":10},"contracts/PearlMiningV4.sol":{"id":12},"contracts/IAgentIdentity.sol":{"id":11},"@openzeppelin/contracts/utils/Panic.sol":{"id":6},"@openzeppelin/contracts/utils/Context.sol":{"id":5},"@openzeppelin/contracts/access/Ownable.sol":{"id":0},"@openzeppelin/contracts/utils/Pausable.sol":{"id":7},"@openzeppelin/contracts/utils/math/Math.sol":{"id":8},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":3},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"id":9},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":1},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":4}},"contracts":{"contracts/PearlMiningV4.sol":{"PearlMiningV4":{"abi":[{"type":"constructor","inputs":[{"name":"registry_","type":"address","internalType":"address"},{"name":"dev_","type":"address","internalType":"address"},{"name":"initialOwner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ERC20InsufficientAllowance","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"allowance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InsufficientBalance","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSpender","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"}]},{"name":"EnforcedPause","type":"error","inputs":[]},{"name":"ExpectedPause","type":"error","inputs":[]},{"name":"InvalidIdentity","type":"error","inputs":[]},{"name":"InvalidSolution","type":"error","inputs":[]},{"name":"InvalidStage","type":"error","inputs":[]},{"name":"MiningAlreadyStarted","type":"error","inputs":[]},{"name":"MiningFinished","type":"error","inputs":[]},{"name":"MiningNotStarted","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":"OwnershipRenunciationDisabled","type":"error","inputs":[]},{"name":"ProofAlreadyUsed","type":"error","inputs":[]},{"name":"RewardChanged","type":"error","inputs":[]},{"name":"WrongRound","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DifficultyStageReached","type":"event","inputs":[{"name":"stage","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"target","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"claims","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Mined","type":"event","inputs":[{"name":"miner","type":"address","indexed":true,"internalType":"address"},{"name":"agentId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"proof","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"nonce","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"claimIndex","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"reward","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MiningStarted","type":"event","inputs":[{"name":"startsAt","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"taskSeed","type":"bytes32","indexed":false,"internalType":"bytes32"}],"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":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"BSC_MAINNET_CODE_HASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"BSC_MAINNET_REGISTRY","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"BURN_ADDRESS","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"BURN_PERCENT","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DIFFICULTY_DENOMINATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DIFFICULTY_NUMERATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"INITIAL_REWARD","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"LIQUIDITY_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_REWARD_STAGE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_STAGE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MAX_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"MINING_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"PUZZLE_VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"REWARD_STEP_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"STAGE_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"WORK_BITS","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"WORK_TARGET","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"challenge","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"seed","type":"bytes32","internalType":"bytes32"},{"name":"target","type":"uint256","internalType":"uint256"},{"name":"reward","type":"uint256","internalType":"uint256"},{"name":"eligible","type":"bool","internalType":"bool"},{"name":"live","type":"bool","internalType":"bool"},{"name":"round","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentGrossReward","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentReward","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentRewardStage","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentStage","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"currentTarget","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"pure"},{"name":"dev","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"isLive","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isOwner","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"agentId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"lastProof","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"mine","type":"function","inputs":[{"name":"id","type":"uint256","internalType":"uint256"},{"name":"expectedRound","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"minReward","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"miningIssued","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"miningMinted","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pauseMining","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"proofDigest","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"},{"name":"nonce","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"publicChallenge","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"puzzleSeed","type":"function","inputs":[{"name":"wallet","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"registry","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IAgentRegistry"}],"stateMutability":"view"},{"name":"registryCodeHash","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"resumeMining","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"rewardForStage","type":"function","inputs":[{"name":"stage","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"rewardStageForIssued","type":"function","inputs":[{"name":"issued","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"rounds","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"stageForIssued","type":"function","inputs":[{"name":"issued","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"startMining","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"startsAt","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"successfulProofs","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"targetForStage","type":"function","inputs":[{"name":"stage","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"taskSeed","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"usedProofs","type":"function","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"registry_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"dev_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialOwner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"allowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"ERC20InsufficientAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"ERC20InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"approver\",\"type\":\"address\"}],\"name\":\"ERC20InvalidApprover\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"ERC20InvalidReceiver\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ERC20InvalidSender\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"ERC20InvalidSpender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"EnforcedPause\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExpectedPause\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidIdentity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSolution\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidStage\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MiningAlreadyStarted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MiningFinished\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MiningNotStarted\",\"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\":\"OwnershipRenunciationDisabled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ProofAlreadyUsed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RewardChanged\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WrongRound\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stage\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"target\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"claims\",\"type\":\"uint256\"}],\"name\":\"DifficultyStageReached\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"miner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"agentId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"proof\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"claimIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"}],\"name\":\"Mined\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"startsAt\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"taskSeed\",\"type\":\"bytes32\"}],\"name\":\"MiningStarted\",\"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\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Unpaused\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BSC_MAINNET_CODE_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"BSC_MAINNET_REGISTRY\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"BURN_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"BURN_PERCENT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DIFFICULTY_DENOMINATOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DIFFICULTY_NUMERATOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIAL_REWARD\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"LIQUIDITY_SUPPLY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MAX_REWARD_STAGE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MAX_STAGE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MAX_SUPPLY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MINING_SUPPLY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PUZZLE_VERSION\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"REWARD_STEP_SUPPLY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"STAGE_SUPPLY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"WORK_BITS\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"WORK_TARGET\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"challenge\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"seed\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"target\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"reward\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"eligible\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"live\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"round\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"currentGrossReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"currentReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"currentRewardStage\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"currentStage\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"currentTarget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"dev\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isLive\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"agentId\",\"type\":\"uint256\"}],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"lastProof\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expectedRound\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minReward\",\"type\":\"uint256\"}],\"name\":\"mine\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"miningIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"miningMinted\",\"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\":[],\"name\":\"pauseMining\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"proofDigest\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"publicChallenge\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wallet\",\"type\":\"address\"}],\"name\":\"puzzleSeed\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"contract IAgentRegistry\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"registryCodeHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeMining\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"stage\",\"type\":\"uint256\"}],\"name\":\"rewardForStage\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"issued\",\"type\":\"uint256\"}],\"name\":\"rewardStageForIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"rounds\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"issued\",\"type\":\"uint256\"}],\"name\":\"stageForIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startMining\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startsAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"successfulProofs\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"stage\",\"type\":\"uint256\"}],\"name\":\"targetForStage\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"taskSeed\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"usedProofs\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"ERC20InsufficientAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failure with the `spender`’s `allowance`. Used in transfers.\",\"params\":{\"allowance\":\"Amount of tokens a `spender` is allowed to operate with.\",\"needed\":\"Minimum amount required to perform a transfer.\",\"spender\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"ERC20InsufficientBalance(address,uint256,uint256)\":[{\"details\":\"Indicates an error related to the current `balance` of a `sender`. Used in transfers.\",\"params\":{\"balance\":\"Current balance for the interacting account.\",\"needed\":\"Minimum amount required to perform a transfer.\",\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC20InvalidApprover(address)\":[{\"details\":\"Indicates a failure with the `approver` of a token to be approved. Used in approvals.\",\"params\":{\"approver\":\"Address initiating an approval operation.\"}}],\"ERC20InvalidReceiver(address)\":[{\"details\":\"Indicates a failure with the token `receiver`. Used in transfers.\",\"params\":{\"receiver\":\"Address to which tokens are being transferred.\"}}],\"ERC20InvalidSender(address)\":[{\"details\":\"Indicates a failure with the token `sender`. Used in transfers.\",\"params\":{\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC20InvalidSpender(address)\":[{\"details\":\"Indicates a failure with the `spender` to be approved. Used in approvals.\",\"params\":{\"spender\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"EnforcedPause()\":[{\"details\":\"The operation failed because the contract is paused.\"}],\"ExpectedPause()\":[{\"details\":\"The operation failed because the contract is not paused.\"}],\"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 the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"Paused(address)\":{\"details\":\"Emitted when the pause is triggered by `account`.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"},\"Unpaused(address)\":{\"details\":\"Emitted when the pause is lifted by `account`.\"}},\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"Returns the value of tokens owned by `account`.\"},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"name()\":{\"details\":\"Returns the name of the token.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"paused()\":{\"details\":\"Returns true if the contract is paused, and false otherwise.\"},\"renounceOwnership()\":{\"details\":\"A renounced owner could permanently prevent start/resume. Use direct ownership transfer.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"Returns the value of tokens in existence.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"currentReward()\":{\"notice\":\"Net payout to the mining wallet, also quoted by challenge().\"},\"rewardForStage(uint256)\":{\"notice\":\"Gross issuance per proof before the blackhole split.\"}},\"notice\":\"Initial100 reward, -10% per20m mined; initial38 work, +50% difficulty per10%. Owner controls mining availability only. ERC20 transfers are not paused.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/PearlMiningV4.sol\":\"PearlMiningV4\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"keccak256\":\"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6\",\"dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a\"]},\"@openzeppelin/contracts/interfaces/draft-IERC6093.sol\":{\"keccak256\":\"0x1b88b3fb3d85ba5496d7d5f396f83ee1fddcdd6762059ff65992655b67920998\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://89393bb3212da1c0889601b9706a07b39419ddc4d2faab9eaf6e7f9152cf6a1c\",\"dweb:/ipfs/QmcCfzzxv1Bkdz1c1yF4gQCeYb6Us5BJANnzTFqawfd1HL\"]},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"keccak256\":\"0x669464167428061ee0f8618b73b3ee90aff8405683e7ddde8cd77dadaa1afe29\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0dda78587a7358b4fdf6b9fca0fde5a5e34930f36d5268a16028627fc0170195\",\"dweb:/ipfs/QmQ1b6cCceDRWNxti9HifsTCzmVP25Haxs1bWugm52vTqH\"]},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303\",\"dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV\"]},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f95ee0bbd4dd3ac730d066ba3e785ded4565e890dbec2fa7d3b9fe3bad9d0d6e\",\"dweb:/ipfs/QmSLr6bHkPFWT7ntj34jmwfyskpwo97T9jZUrk5sz3sdtR\"]},\"@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/Pausable.sol\":{\"keccak256\":\"0xdb484371dfbb848cb6f5d70464e9ac9b2900e4164ead76bbce4fef0b44bcc68f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f9d6f6f6600a2bec622f699081b58350873b5e63ce05464d17d674a290bb8a7c\",\"dweb:/ipfs/QmQKVzSQY1PM3Bid4QhgVVZyx6B4Jx7XgaQzLKHj38vJz8\"]},\"@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\"]},\"contracts/AgentIdGate.sol\":{\"keccak256\":\"0x3a66b322d0518dd7bf89d40a50c7b4c494e3594dd0909108572f366b2c8e8c8f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bfe2f204c557d917db9794555a9f070ec716654723173dadc054932953b09d56\",\"dweb:/ipfs/QmeA2DPfkuE95LQrwnG8ptUycfwkHWQDeXobCa4vgakCyD\"]},\"contracts/IAgentIdentity.sol\":{\"keccak256\":\"0x675b12455cbc0f974b52c32dde0c30621fd0b139457d9ddbe8a4b8ff07224f7e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://17001a66b4c091de196004bc3dd08eaf543e54af0740c8cebb01fd62365bee2c\",\"dweb:/ipfs/QmQuU3AGzf3Fsg42f77wb9XD5TvPkhxQvDiKbpPMPR2qhC\"]},\"contracts/PearlMiningV4.sol\":{\"keccak256\":\"0xa8fa2347186e820e515f96a7ce9c7d586fbde4e9c5a55e6640c3bb83ace0c0f1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://256cf4d0fd3ece66569c92e8571f624edcf96a301fd94a049a3a810be035f49d\",\"dweb:/ipfs/QmY8XrEATQ6i6KxJVpJbbkcZWjW4bhf411Dem9LyRmcWea\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Initial100 reward, -10% per20m mined; initial38 work, +50% difficulty per10%. Owner controls mining availability only. ERC20 transfers are not paused.","methods":{"currentReward()":{"notice":"Net payout to the mining wallet, also quoted by challenge()."},"rewardForStage(uint256)":{"notice":"Gross issuance per proof before the blackhole split."}},"version":1},"devdoc":{"kind":"dev","errors":{"EnforcedPause()":[{"details":"The operation failed because the contract is paused."}],"ExpectedPause()":[{"details":"The operation failed because the contract is not paused."}],"ERC20InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC20InvalidSpender(address)":[{"params":{"spender":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `spender` to be approved. Used in approvals."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"ERC20InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC20InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred.","balance":"Current balance for the interacting account."},"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers."}],"ERC20InsufficientAllowance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner.","allowance":"Amount of tokens a `spender` is allowed to operate with."},"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers."}]},"events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."},"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"Returns the value of tokens in existence."},"balanceOf(address)":{"details":"Returns the value of tokens owned by `account`."},"renounceOwnership()":{"details":"A renounced owner could permanently prevent start/resume. Use direct ownership transfer."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"allowance(address,address)":{"details":"Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_bytes32,t_bool)":{"key":"t_bytes32","label":"mapping(bytes32 => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_bytes32)":{"key":"t_address","label":"mapping(address => bytes32)","value":"t_bytes32","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":307,"label":"_balances","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":313,"label":"_allowances","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"2","type":"t_uint256","astId":315,"label":"_totalSupply","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"3","type":"t_string_storage","astId":317,"label":"_name","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"4","type":"t_string_storage","astId":319,"label":"_symbol","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"5","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"5","type":"t_bool","astId":994,"label":"_paused","offset":20,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"6","type":"t_uint256","astId":4790,"label":"startsAt","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"7","type":"t_bytes32","astId":4792,"label":"taskSeed","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"8","type":"t_uint256","astId":4794,"label":"successfulProofs","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"9","type":"t_uint256","astId":4796,"label":"miningMinted","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"10","type":"t_mapping(t_bytes32,t_bool)","astId":4800,"label":"usedProofs","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"11","type":"t_mapping(t_address,t_uint256)","astId":4804,"label":"rounds","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"},{"slot":"12","type":"t_mapping(t_address,t_bytes32)","astId":4808,"label":"lastProof","offset":0,"contract":"contracts/PearlMiningV4.sol:PearlMiningV4"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"545:7483:12:-:0;;;2514:303;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2666:12;2647:9;1582:113:2;;;;;;;;;;;;;-1:-1:-1;;;1582:113:2;;;;;;;;;;;;;;;;-1:-1:-1;;;1582:113:2;;;1656:5;1648;:13;;;;;;:::i;:::-;-1:-1:-1;1671:7:2;:17;1681:7;1671;:17;:::i;:::-;;1582:113;;982:1:10;958:9;-1:-1:-1;;;;;958:21:10;;:25;950:58;;;;-1:-1:-1;;;950:58:10;;3422:2:13;950:58:10;;;3404:21:13;3461:2;3441:18;;;3434:30;3500:22;3480:18;;;3473:50;3540:18;;950:58:10;;;;;;;;;1022:13;1039:2;1022:19;1018:212;;-1:-1:-1;;;;;1065:33:10;;648:42;1065:33;1057:71;;;;-1:-1:-1;;;1057:71:10;;3771:2:13;1057:71:10;;;3753:21:13;3810:2;3790:18;;;3783:30;3849:27;3829:18;;;3822:55;3894:18;;1057:71:10;3569:349:13;1057:71:10;-1:-1:-1;;;;;1150:18:10;;;744:66;1150:43;1142:77;;;;-1:-1:-1;;;1142:77:10;;4125:2:13;1142:77:10;;;4107:21:13;4164:2;4144:18;;;4137:30;4203:23;4183:18;;;4176:51;4244:18;;1142:77:10;3923:345:13;1142:77:10;-1:-1:-1;;;;;1239:36:10;;;;;;;1304:18;1285:37;;1273:26:0;;1269:95;;1322:31;;-1:-1:-1;;;1322:31:0;;1350:1;1322:31;;;4419:51:13;4392:18;;1322:31:0;4273:203:13;1269:95:0;1373:32;1392:12;1373:18;:32::i;:::-;-1:-1:-1;;;;;;2702:18:12;::::3;2694:39;;;::::0;-1:-1:-1;;;2694:39:12;;4683:2:13;2694:39:12::3;::::0;::::3;4665:21:13::0;4722:1;4702:18;;;4695:29;-1:-1:-1;;;4740:18:13;;;4733:38;4788:18;;2694:39:12::3;4481:331:13::0;2694:39:12::3;-1:-1:-1::0;;;;;2743:10:12;::::3;;::::0;2763:29:::3;2749:4:::0;725:22:::3;2763:5;:29::i;:::-;2802:8;:6;:8::i;:::-;2514:303:::0;;;545:7483;;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;7362:208:2:-;-1:-1:-1;;;;;7432:21:2;;7428:91;;7476:32;;-1:-1:-1;;;7476:32:2;;7505:1;7476:32;;;4419:51:13;4392:18;;7476:32:2;4273:203:13;7428:91:2;7528:35;7544:1;7548:7;7557:5;7528:7;:35::i;:::-;7362:208;;:::o;2339:115:7:-;1350:19;:17;:19::i;:::-;2398:7:::1;:14:::0;;-1:-1:-1;;;;2398:14:7::1;-1:-1:-1::0;;;2398:14:7::1;::::0;;2427:20:::1;2434:12;735:10:5::0;;656:96;2434:12:7::1;2427:20;::::0;-1:-1:-1;;;;;4437:32:13;;;4419:51;;4407:2;4392:18;2427:20:7::1;;;;;;;2339:115::o:0;5912:1107:2:-;-1:-1:-1;;;;;6001:18:2;;5997:540;;6153:5;6137:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;5997:540:2;;-1:-1:-1;5997:540:2;;-1:-1:-1;;;;;6211:15:2;;6189:19;6211:15;;;;;;;;;;;6244:19;;;6240:115;;;6290:50;;-1:-1:-1;;;6290:50:2;;-1:-1:-1;;;;;5264:32:13;;6290:50:2;;;5246:51:13;5313:18;;;5306:34;;;5356:18;;;5349:34;;;5219:18;;6290:50:2;5044:345:13;6240:115:2;-1:-1:-1;;;;;6475:15:2;;:9;:15;;;;;;;;;;6493:19;;;;6475:37;;5997:540;-1:-1:-1;;;;;6551:16:2;;6547:425;;6714:12;:21;;;;;;;6547:425;;;-1:-1:-1;;;;;6925:13:2;;:9;:13;;;;;;;;;;:22;;;;;;6547:425;7002:2;-1:-1:-1;;;;;6987:25:2;6996:4;-1:-1:-1;;;;;6987:25:2;;7006:5;6987:25;;;;5540::13;;5528:2;5513:18;;5394:177;6987:25:2;;;;;;;;5912:1107;;;:::o;1878:128:7:-;1943:8;1796:7;;-1:-1:-1;;;1796:7:7;;;;;1726:84;1943:8;1939:61;;;1974:15;;-1:-1:-1;;;1974:15:7;;;;;;;;;;;1939:61;1878:128::o;14:177:13:-;93:13;;-1:-1:-1;;;;;135:31:13;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:378::-;284:6;292;300;353:2;341:9;332:7;328:23;324:32;321:52;;;369:1;366;359:12;321:52;392:40;422:9;392:40;:::i;:::-;382:50;;451:49;496:2;485:9;481:18;451:49;:::i;:::-;441:59;;519:49;564:2;553:9;549:18;519:49;:::i;:::-;509:59;;196:378;;;;;:::o;579:127::-;640:10;635:3;631:20;628:1;621:31;671:4;668:1;661:15;695:4;692:1;685:15;711:380;790:1;786:12;;;;833;;;854:61;;908:4;900:6;896:17;886:27;;854:61;961:2;953:6;950:14;930:18;927:38;924:161;;1007:10;1002:3;998:20;995:1;988:31;1042:4;1039:1;1032:15;1070:4;1067:1;1060:15;924:161;;711:380;;;:::o;1222:518::-;1324:2;1319:3;1316:11;1313:421;;;1360:5;1357:1;1350:16;1404:4;1401:1;1391:18;1474:2;1462:10;1458:19;1455:1;1451:27;1445:4;1441:38;1510:4;1498:10;1495:20;1492:47;;;-1:-1:-1;1533:4:13;1492:47;1588:2;1583:3;1579:12;1576:1;1572:20;1566:4;1562:31;1552:41;;1643:81;1661:2;1654:5;1651:13;1643:81;;;1720:1;1706:16;;1687:1;1676:13;1643:81;;;1647:3;;1313:421;1222:518;;;:::o;1916:1299::-;2036:10;;-1:-1:-1;;;;;2058:30:13;;2055:56;;;2091:18;;:::i;:::-;2120:97;2210:6;2170:38;2202:4;2196:11;2170:38;:::i;:::-;2164:4;2120:97;:::i;:::-;2266:4;2297:2;2286:14;;2314:1;2309:649;;;;3002:1;3019:6;3016:89;;;-1:-1:-1;3071:19:13;;;3065:26;3016:89;-1:-1:-1;;1873:1:13;1869:11;;;1865:24;1861:29;1851:40;1897:1;1893:11;;;1848:57;3118:81;;2279:930;;2309:649;1169:1;1162:14;;;1206:4;1193:18;;-1:-1:-1;;2345:20:13;;;2463:222;2477:7;2474:1;2471:14;2463:222;;;2559:19;;;2553:26;2538:42;;2666:4;2651:20;;;;2619:1;2607:14;;;;2493:12;2463:222;;;2467:3;2713:6;2704:7;2701:19;2698:201;;;2774:19;;;2768:26;-1:-1:-1;;2857:1:13;2853:14;;;2869:3;2849:24;2845:37;2841:42;2826:58;2811:74;;2698:201;-1:-1:-1;;;;2945:1:13;2929:14;;;2925:22;2912:36;;-1:-1:-1;1916:1299:13:o;4817:222::-;4882:9;;;4903:10;;;4900:133;;;4955:10;4950:3;4946:20;4943:1;4936:31;4990:4;4987:1;4980:15;5018:4;5015:1;5008:15;4900:133;4817:222;;;;:::o;5394:177::-;545:7483:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"545:7483:12:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5775:158;;;:::i;:::-;;;160:25:13;;;148:2;133:18;5775:158:12;;;;;;;;1760:89:2;;;:::i;:::-;;;;;;;:::i;4655:150:12:-;;;:::i;862:41:10:-;;;;;3902:186:2;;;;;;:::i;:::-;;:::i;:::-;;;1707:14:13;;1700:22;1682:41;;1670:2;1655:18;3902:186:2;1542:187:13;3256:121:12;;;:::i;:::-;;2803:97:2;2881:12;;2803:97;;1177:50:12;;1226:1;1177:50;;2900:350;;;:::i;4680:244:2:-;;;;;;:::i;:::-;;:::i;954:45:12:-;;997:2;954:45;;2823:71;;;2889:2;2389:36:13;;2377:2;2362:18;2823:71:12;2247:184:13;682:65:12;;725:22;682:65;;615:61;;652:24;615:61;;882:66;;927:21;882:66;;821:55;;862:14;821:55;;5421:97;;;:::i;1123:48::-;;1170:1;1123:48;;1296:37;;1332:1;1296:37;;1473:135;;1514:94;1473:135;;3383:124;;;:::i;1744:27::-;;;;;;1707:31;;;;;;5322:94;;;:::i;1726:84:7:-;1796:7;;-1:-1:-1;;;1796:7:7;;;;1726:84;;1825:41:12;;;;;;:::i;:::-;;;;;;;;;;;;;;2933:116:2;;;;;;:::i;:::-;-1:-1:-1;;;;;3024:18:2;2998:7;3024:18;;;;;;;;;;;;2933:116;3615:110:12;;;:::i;816:40:10:-;;;;;;;;-1:-1:-1;;;;;2875:32:13;;;2857:51;;2845:2;2830:18;816:40:10;2688:226:13;6596:1430:12;;;;;;:::i;:::-;;:::i;3961:321::-;;;;;;:::i;:::-;;:::i;1638:85:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;1638:85;;3731:155:12;;;;;;:::i;:::-;;:::i;1615:28::-;;;;;601:89:10;;648:42;601:89;;5523:80:12;5588:12;;5523:80;;1962:93:2;;;:::i;696:114:10:-;;744:66;696:114;;1339:41:12;;1378:2;1339:41;;3244:178:2;;;;;;:::i;:::-;;:::i;6278:312:12:-;;;;;;:::i;:::-;;:::i;:::-;;;;4225:25:13;;;4281:2;4266:18;;4259:34;;;;4309:18;;;4302:34;;;;4379:14;4372:22;4367:2;4352:18;;4345:50;4439:14;4432:22;4426:3;4411:19;;4404:51;4486:3;4471:19;;4464:35;4212:3;4197:19;6278:312:12;3950:555:13;4412:160:12;;;:::i;1649:23::-;;;;;;5608:161;;;:::i;1678:23::-;;;;;;753:62;;793:22;753:62;;1777:42;;;;;;:::i;:::-;;;;;;;;;;;;;;;;1005:38;;1041:2;1005:38;;1872:44;;;;;;:::i;:::-;;;;;;;;;;;;;;5939:173;;;;;;:::i;:::-;;:::i;1233:57::-;;;:::i;5074:243::-;;;;;;:::i;:::-;;:::i;3455:140:2:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3561:18:2;;;3535:7;3561:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3455:140;1334:530:10;;;;;;:::i;:::-;;:::i;4933:136:12:-;;;;;;:::i;:::-;;:::i;2543:215:0:-;;;;;;:::i;:::-;;:::i;4288:118:12:-;;;:::i;1049:68::-;;-1:-1:-1;;;;;1049:68:12;;1386:81;;1425:42;1386:81;;6118:154;;;;;;:::i;:::-;;:::i;5775:158::-;5916:8;;5859:66;;;1514:94;5859:66;;;5319:25:13;5886:13:12;5360:18:13;;;5353:34;;;;5909:4:12;5403:18:13;;;5396:60;5472:18;;;5465:34;;;;5823:7:12;;5291:19:13;;5859:66:12;;;;;;;;;;;;5849:77;;;;;;5842:84;;5775:158;:::o;1760:89:2:-;1805:13;1837:5;1830:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1760:89;:::o;4655:150:12:-;4701:7;4720:13;4736:20;:18;:20::i;:::-;4720:36;;4781:17;4792:5;4781:10;:17::i;:::-;4773:25;;:5;:25;:::i;:::-;4766:32;;;4655:150;:::o;3902:186:2:-;3975:4;735:10:5;4029:31:2;735:10:5;4045:7:2;4054:5;4029:8;:31::i;:::-;4077:4;4070:11;;;3902:186;;;;;:::o;3256:121:12:-;1531:13:0;:11;:13::i;:::-;3312:8:12::1;;3324:1;3312:13:::0;3308:44:::1;;3334:18;;-1:-1:-1::0;;;3334:18:12::1;;;;;;;;;;;3308:44;3362:8;:6;:8::i;:::-;3256:121::o:0;2900:350::-;1531:13:0;:11;:13::i;:::-;2956:8:12::1;::::0;:13;2952:48:::1;;2978:22;;-1:-1:-1::0;;;2978:22:12::1;;;;;;;;;;;2952:48;3021:15;3010:8;:26:::0;1514:94:::1;3094:13;3117:4;3146:16;3161:1;3146:12;:16;:::i;:::-;3165:8;::::0;3067:107:::1;::::0;;::::1;::::0;::::1;6419:25:13::0;;;;6460:18;;6453:34;;;;-1:-1:-1;;;;;6523:32:13;;;6503:18;;;6496:60;3136:27:12::1;6572:18:13::0;;;6565:34;6615:19;;;6608:35;6391:19;;3067:107:12::1;::::0;;-1:-1:-1;;3067:107:12;;::::1;::::0;;;;;;3057:118;;3067:107:::1;3057:118:::0;;::::1;::::0;3046:8:::1;:129:::0;3185:10:::1;:8;:10::i;:::-;3210:33;3224:8;;3234;;3210:33;;;;;;6828:25:13::0;;;6884:2;6869:18;;6862:34;6816:2;6801:18;;6654:248;3210:33:12::1;;;;;;;;2900:350::o:0;4680:244:2:-;4767:4;735:10:5;4823:37:2;4839:4;735:10:5;4854:5:2;4823:15;:37::i;:::-;4870:26;4880:4;4886:2;4890:5;4870:9;:26::i;:::-;4913:4;4906:11;;;4680:244;;;;;;:::o;5421:97:12:-;5467:7;5485:30;5500:14;:12;:14::i;5485:30::-;5478:37;;5421:97;:::o;3383:124::-;1531:13:0;:11;:13::i;:::-;3440:8:12::1;;3452:1;3440:13:::0;3436:44:::1;;3462:18;;-1:-1:-1::0;;;3462:18:12::1;;;;;;;;;;;3436:44;3490:10;:8;:10::i;5322:94::-:0;5367:7;5385:28;5400:12;;5385:14;:28::i;3615:110::-;1531:13:0;:11;:13::i;:::-;3687:31:12::1;;-1:-1:-1::0;;;3687:31:12::1;;;;;;;;;;;6596:1430:::0;1350:19:7;:17;:19::i;:::-;6716:8:12::1;;6728:1;6716:13:::0;6712:44:::1;;6738:18;;-1:-1:-1::0;;;6738:18:12::1;;;;;;;;;;;6712:44;6777:10;6770:18;::::0;;;:6:::1;:18;::::0;;;;;:35;::::1;6766:60;;6814:12;;-1:-1:-1::0;;;6814:12:12::1;;;;;;;;;;;6766:60;6841:27;::::0;-1:-1:-1;;;6841:27:12;;6854:10:::1;6841:27;::::0;::::1;7081:51:13::0;7148:18;;;7141:34;;;6841:4:12::1;::::0;:12:::1;::::0;7054:18:13;;6841:27:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6836:58;;6877:17;;-1:-1:-1::0;;;6877:17:12::1;;;;;;;;;;;6836:58;6920:16;::::0;6977:12:::1;::::0;6904:13:::1;::::0;6962:28:::1;::::0;:14:::1;:28::i;:::-;6946:44;;7000:13;7016:29;7028:10;7039:5;7016:11;:29::i;:::-;7059:17;::::0;;;:10:::1;:17;::::0;;;;;7000:45;;-1:-1:-1;7059:17:12::1;;7055:48;;;7085:18;;-1:-1:-1::0;;;7085:18:12::1;;;;;;;;;;;7055:48;7134:21;7149:5;7134:14;:21::i;:::-;7117:38:::0;::::1;7113:68;;;7164:17;;-1:-1:-1::0;;;7164:17:12::1;;;;;;;;;;;7113:68;793:22;7195:12;;:29;7191:58;;7233:16;;-1:-1:-1::0;;;7233:16:12::1;;;;;;;;;;;7191:58;7259:13;7275:20;:18;:20::i;:::-;7259:36;;7305:14;7322:17;7333:5;7322:10;:17::i;:::-;7305:34:::0;-1:-1:-1;7349:14:12::1;7366;7305:34:::0;7366:5;:14:::1;:::i;:::-;7349:31;;7403:9;7394:6;:18;7390:46;;;7421:15;;-1:-1:-1::0;;;7421:15:12::1;;;;;;;;;;;7390:46;7446:17;::::0;;;:10:::1;:17;::::0;;;;:24;;-1:-1:-1;;7446:24:12::1;7466:4;7446:24:::0;;::::1;::::0;;;7501:17:::1;::::0;:13;;:17:::1;:::i;:::-;7487:10;7480:18;::::0;;;:6:::1;:18;::::0;;;;;;;:38;;;;7528:9:::1;:21:::0;;;:29;;;7586:9:::1;:5:::0;7594:1:::1;7586:9;:::i;:::-;7567:16;:28;;;;7621:5;7605:12;;:21;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;7663:12:12::1;::::0;652:24:::1;::::0;7644:31:::1;::::0;725:22:::1;7644:31;:::i;:::-;:45;;7636:68;;;::::0;-1:-1:-1;;;7636:68:12;;7800:2:13;7636:68:12::1;::::0;::::1;7782:21:13::0;7839:2;7819:18;;;7812:30;-1:-1:-1;;;7858:18:13;;;7851:40;7908:18;;7636:68:12::1;;;;;;;;;7719:45;::::0;;8139:25:13;;;8195:2;8180:18;;8173:34;;;8223:18;;;8216:34;;;7739:5:12;;7736:2;;7725:10:::1;::::0;7719:45:::1;::::0;8127:2:13;8112:18;7719:45:12::1;;;;;;;7774:17;7794:28;7809:12;;7794:14;:28::i;:::-;7774:48;;7849:5;7836:9;:18;7832:98;;7861:69;7884:9;7894:25;7909:9;7894:14;:25::i;:::-;7920:9;:5:::0;7928:1:::1;7920:9;:::i;:::-;7861:69;::::0;;8139:25:13;;;8195:2;8180:18;;8173:34;;;;8223:18;;;8216:34;8127:2;8112:18;7861:69:12::1;;;;;;;7832:98;7940:25;7946:10;7958:6;7940:5;:25::i;:::-;7979:11:::0;;7975:44:::1;;7992:27;1425:42;8012:6;7992:5;:27::i;:::-;6702:1324;;;;;;;6596:1430:::0;;;;:::o;3961:321::-;4021:14;997:2;4051:5;:24;4047:51;;;4084:14;;-1:-1:-1;;;4084:14:12;;;;;;;;;;;4047:51;-1:-1:-1;862:14:12;4224:9;4219:56;4239:5;4235:1;:9;4219:56;;;4273:2;4260:10;:6;4269:1;4260:10;:::i;:::-;:15;;;;:::i;:::-;4251:24;-1:-1:-1;4246:3:12;;4219:56;;;;3961:321;;;:::o;3731:155::-;3798:7;3824:55;997:2;3851:27;927:21;3851:6;:27;:::i;:::-;3824:8;:55::i;1962:93:2:-;2009:13;2041:7;2034:14;;;;;:::i;3244:178::-;3313:4;735:10:5;3367:27:2;735:10:5;3384:2:2;3388:5;3367:9;:27::i;6278:312:12:-;6357:12;6371:14;6387;6403:13;6418:9;6429:13;6467:18;6478:6;6467:10;:18::i;:::-;6487:15;:13;:15::i;:::-;6504;:13;:15::i;:::-;6521:23;;-1:-1:-1;;;6521:23:12;;-1:-1:-1;;;;;7099:32:13;;6521:23:12;;;7081:51:13;7148:18;;;7141:34;;;6521:4:12;;:12;;7054:18:13;;6521:23:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6558:8;:6;:8::i;:::-;-1:-1:-1;;;;;6568:14:12;;;;;;;;:6;:14;;;;;;6459:124;;;;;;-1:-1:-1;6459:124:12;-1:-1:-1;6459:124:12;-1:-1:-1;6568:14:12;;-1:-1:-1;6278:312:12;-1:-1:-1;;;6278:312:12:o;4412:160::-;4463:7;4489:76;4498:36;4513:20;:18;:20::i;4498:36::-;4552:12;;4536:28;;793:22;4536:28;:::i;5608:161::-;5647:4;5670:8;;5682:1;5670:13;;:26;;;;-1:-1:-1;1796:7:7;;-1:-1:-1;;;1796:7:7;;;;5687:9:12;5670:26;:56;;;;;652:24;5700:13;2881:12:2;;;2803:97;5700:13:12;:26;5670:56;:92;;;;;5742:15;:13;:15::i;:::-;:20;;5663:99;;5608:161;:::o;5939:173::-;5996:7;6043:17;:15;:17::i;:::-;-1:-1:-1;;;;;6070:14:12;;;;;;:6;:14;;;;;;;;;6086:9;:17;;;;;;;6032:72;;;;;9019:25:13;;;;9060:18;;9053:60;;;;9129:18;;;9122:34;9172:18;;;9165:34;;;;8991:19;;6032:72:12;;;;;;;;;;;;6022:83;;;;;;6015:90;;5939:173;;;:::o;1233:57::-;1272:18;1288:2;793:22;1272:18;:::i;:::-;1233:57;:::o;5074:243::-;5142:7;1332:1;5165:5;:17;5161:44;;;5191:14;;-1:-1:-1;;;5191:14:12;;;;;;;;;;;5161:44;5222:88;-1:-1:-1;;;;;5247:31:12;5273:5;1226:1;5247:31;:::i;:::-;5280:29;5304:5;1170:1;5280:29;:::i;:::-;5222:11;:88::i;1334:530:10:-;1407:4;-1:-1:-1;;;;;1427:20:10;;;;:70;;;1481:16;1459:8;-1:-1:-1;;;;;1451:26:10;;:46;;1427:70;1423:88;;;-1:-1:-1;1506:5:10;1499:12;;1423:88;1525:25;;-1:-1:-1;;;1525:25:10;;;;;160::13;;;1525:8:10;-1:-1:-1;;;;;1525:16:10;;;;133:18:13;;1525:25:10;;;;;;;;;;;;;;;;;;-1:-1:-1;1525:25:10;;;;;;;;-1:-1:-1;;1525:25:10;;;;;;;;;;;;:::i;:::-;;;1521:138;;-1:-1:-1;1651:5:10;1644:12;;1521:138;1604:6;-1:-1:-1;;;;;1594:16:10;:6;-1:-1:-1;;;;;1594:16:10;;1590:34;;1619:5;1612:12;;;;;1590:34;-1:-1:-1;1672:25:10;;-1:-1:-1;;;1672:25:10;;-1:-1:-1;;;;;2875:32:13;;;1672:25:10;;;2857:51:13;1672:8:10;:17;;;;2830:18:13;;1672:25:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1672:25:10;;;;;;;;;;;;:::i;:::-;;;1668:190;;-1:-1:-1;1850:5:10;1843:12;;1668:190;1750:20;;:25;;;;:73;;-1:-1:-1;1787:24:10;;;;;;1779:44;;1750:73;1743:80;;;;;4933:136:12;4994:7;5020:42;1332:1;1272:18;1288:2;793:22;1272:18;:::i;:::-;5040:21;;:6;:21;:::i;2543:215:0:-;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:0;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:0;;2700:1:::1;2672:31;::::0;::::1;2857:51:13::0;2830:18;;2672:31:0::1;2688:226:13::0;2623:91:0::1;2723:28;2742:8;2723:18;:28::i;:::-;2543:215:::0;:::o;4288:118:12:-;4339:7;4365:34;4386:12;;4365:20;:34::i;6118:154::-;6191:7;6238:18;6249:6;6238:10;:18::i;:::-;6227:37;;;;;;6828:25:13;;;;6869:18;;6862:34;;;6801:18;;6227:37:12;;;;;;;;;;;;6217:48;;;;;;6210:55;;6118:154;;;;:::o;4811:116::-;4868:7;4917:3;4894:20;1378:2;4894:5;:20;:::i;:::-;:26;;;;:::i;8630:128:2:-;8714:37;8723:5;8730:7;8739:5;8746:4;8714:8;:37::i;:::-;8630:128;;;:::o;1796:162:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;735:10:5;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:5;1901:40:0;;;2857:51:13;2830:18;;1901:40:0;2688:226:13;2339:115:7;1350:19;:17;:19::i;:::-;2398:7:::1;:14:::0;;-1:-1:-1;;;;2398:14:7::1;-1:-1:-1::0;;;2398:14:7::1;::::0;;2427:20:::1;2434:12;735:10:5::0;;656:96;2434:12:7::1;2427:20;::::0;-1:-1:-1;;;;;2875:32:13;;;2857:51;;2845:2;2830:18;2427:20:7::1;2688:226:13::0;2586:117:7;1597:16;:14;:16::i;:::-;2644:7:::1;:15:::0;;-1:-1:-1;;;;2644:15:7::1;::::0;;2674:22:::1;735:10:5::0;2683:12:7::1;656:96:5::0;10321:476:2;-1:-1:-1;;;;;3561:18:2;;;10420:24;3561:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;10486:36:2;;10482:309;;;10561:5;10542:16;:24;10538:130;;;10593:60;;-1:-1:-1;;;10593:60:2;;-1:-1:-1;;;;;12415:32:13;;10593:60:2;;;12397:51:13;12464:18;;;12457:34;;;12507:18;;;12500:34;;;12370:18;;10593:60:2;12195:345:13;10538:130:2;10709:57;10718:5;10725:7;10753:5;10734:16;:24;10760:5;10709:8;:57::i;:::-;10410:387;10321:476;;;:::o;5297:300::-;-1:-1:-1;;;;;5380:18:2;;5376:86;;5421:30;;-1:-1:-1;;;5421:30:2;;5448:1;5421:30;;;2857:51:13;2830:18;;5421:30:2;2688:226:13;5376:86:2;-1:-1:-1;;;;;5475:16:2;;5471:86;;5514:32;;-1:-1:-1;;;5514:32:2;;5543:1;5514:32;;;2857:51:13;2830:18;;5514:32:2;2688:226:13;5471:86:2;5566:24;5574:4;5580:2;5584:5;5566:7;:24::i;1878:128:7:-;1796:7;;-1:-1:-1;;;1796:7:7;;;;1939:61;;;1974:15;;-1:-1:-1;;;1974:15:7;;;;;;;;;;;7362:208:2;-1:-1:-1;;;;;7432:21:2;;7428:91;;7476:32;;-1:-1:-1;;;7476:32:2;;7505:1;7476:32;;;2857:51:13;2830:18;;7476:32:2;2688:226:13;7428:91:2;7528:35;7544:1;7548:7;7557:5;7528:7;:35::i;:::-;7362:208;;:::o;5633:111:8:-;5691:7;5328:5;;;5725;;;5327:36;5322:42;;5717:20;5087:294;7296:3683;7378:14;7429:12;7443:11;7458:12;7465:1;7468;7458:6;:12::i;:::-;7428:42;;;;7552:4;7560:1;7552:9;7548:365;;7887:11;7881:3;:17;;;;;:::i;:::-;;7874:24;;;;;;7548:365;8038:4;8023:11;:19;8019:142;;8062:84;5328:5;8082:16;;5327:36;940:4:6;5322:42:8;8062:11;:84::i;:::-;8413:17;8564:11;8561:1;8558;8551:25;8956:12;8986:15;;;8971:31;;9121:22;;;;;9854:1;9835;:15;;9834:21;;10087;;;10083:25;;10072:36;10157:21;;;10153:25;;10142:36;10229:21;;;10225:25;;10214:36;10300:21;;;10296:25;;10285:36;10373:21;;;10369:25;;10358:36;10447:21;;;10443:25;;;10432:36;9363:12;;;;9359:23;;;9384:1;9355:31;8676:18;;;8666:29;;;9470:11;;;;8719:19;;;;9214:14;;;;9463:18;;;;10922:13;;-1:-1:-1;;7296:3683:8;;;;;:::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;9607:432:2:-;-1:-1:-1;;;;;9719:19:2;;9715:89;;9761:32;;-1:-1:-1;;;9761:32:2;;9790:1;9761:32;;;2857:51:13;2830:18;;9761:32:2;2688:226:13;9715:89:2;-1:-1:-1;;;;;9817:21:2;;9813:90;;9861:31;;-1:-1:-1;;;9861:31:2;;9889:1;9861:31;;;2857:51:13;2830:18;;9861:31:2;2688:226:13;9813:90:2;-1:-1:-1;;;;;9912:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;9957:76;;;;10007:7;-1:-1:-1;;;;;9991:31:2;10000:5;-1:-1:-1;;;;;9991:31:2;;10016:5;9991:31;;;;160:25:13;;148:2;133:18;;14:177;9991:31:2;;;;;;;;9607:432;;;;:::o;2078:126:7:-;1796:7;;-1:-1:-1;;;1796:7:7;;;;2136:62;;2172:15;;-1:-1:-1;;;2172:15:7;;;;;;;;;;;5912:1107:2;-1:-1:-1;;;;;6001:18:2;;5997:540;;6153:5;6137:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;5997:540:2;;-1:-1:-1;5997:540:2;;-1:-1:-1;;;;;6211:15:2;;6189:19;6211:15;;;;;;;;;;;6244:19;;;6240:115;;;6290:50;;-1:-1:-1;;;6290:50:2;;-1:-1:-1;;;;;12415:32:13;;6290:50:2;;;12397:51:13;12464:18;;;12457:34;;;12507:18;;;12500:34;;;12370:18;;6290:50:2;12195:345:13;6240:115:2;-1:-1:-1;;;;;6475:15:2;;:9;:15;;;;;;;;;;6493:19;;;;6475:37;;5997:540;-1:-1:-1;;;;;6551:16:2;;6547:425;;6714:12;:21;;;;;;;6547:425;;;-1:-1:-1;;;;;6925:13:2;;:9;:13;;;;;;;;;;:22;;;;;;6547:425;7002:2;-1:-1:-1;;;;;6987:25:2;6996:4;-1:-1:-1;;;;;6987:25:2;;7006:5;6987:25;;;;160::13;;148:2;133:18;;14:177;6987:25:2;;;;;;;;5912:1107;;;:::o;1027:550:8:-;1088:12;;-1:-1:-1;;1471:1:8;1468;1461:20;1501:9;;;;1549:11;;;1535:12;;;;1531:30;;;;;1027:550;-1:-1:-1;;1027:550:8:o;1776:194:6:-;1881:10;1875:4;1868:24;1918:4;1912;1905:18;1949:4;1943;1936:18;196:250:13;281:1;291:113;305:6;302:1;299:13;291:113;;;381:11;;;375:18;362:11;;;355:39;327:2;320:10;291:113;;;-1:-1:-1;;438:1:13;420:16;;413:27;196:250::o;451:396::-;600:2;589:9;582:21;563:4;632:6;626:13;675:6;670:2;659:9;655:18;648:34;691:79;763:6;758:2;747:9;743:18;738:2;730:6;726:15;691:79;:::i;:::-;831:2;810:15;-1:-1:-1;;806:29:13;791:45;;;;838:2;787:54;;451:396;-1:-1:-1;;451:396:13:o;1034:131::-;-1:-1:-1;;;;;1109:31:13;;1099:42;;1089:70;;1155:1;1152;1145:12;1170:367;1238:6;1246;1299:2;1287:9;1278:7;1274:23;1270:32;1267:52;;;1315:1;1312;1305:12;1267:52;1354:9;1341:23;1373:31;1398:5;1373:31;:::i;:::-;1423:5;1501:2;1486:18;;;;1473:32;;-1:-1:-1;;;1170:367:13:o;1734:508::-;1811:6;1819;1827;1880:2;1868:9;1859:7;1855:23;1851:32;1848:52;;;1896:1;1893;1886:12;1848:52;1935:9;1922:23;1954:31;1979:5;1954:31;:::i;:::-;2004:5;-1:-1:-1;2061:2:13;2046:18;;2033:32;2074:33;2033:32;2074:33;:::i;:::-;1734:508;;2126:7;;-1:-1:-1;;;2206:2:13;2191:18;;;;2178:32;;1734:508::o;2436:247::-;2495:6;2548:2;2536:9;2527:7;2523:23;2519:32;2516:52;;;2564:1;2561;2554:12;2516:52;2603:9;2590:23;2622:31;2647:5;2622:31;:::i;2919:587::-;3005:6;3013;3021;3029;3082:3;3070:9;3061:7;3057:23;3053:33;3050:53;;;3099:1;3096;3089:12;3050:53;-1:-1:-1;;3144:23:13;;;3264:2;3249:18;;3236:32;;-1:-1:-1;3367:2:13;3352:18;;3339:32;;3470:2;3455:18;3442:32;;-1:-1:-1;2919:587:13;-1:-1:-1;2919:587:13:o;3511:226::-;3570:6;3623:2;3611:9;3602:7;3598:23;3594:32;3591:52;;;3639:1;3636;3629:12;3591:52;-1:-1:-1;3684:23:13;;3511:226;-1:-1:-1;3511:226:13:o;4695:388::-;4763:6;4771;4824:2;4812:9;4803:7;4799:23;4795:32;4792:52;;;4840:1;4837;4830:12;4792:52;4879:9;4866:23;4898:31;4923:5;4898:31;:::i;:::-;4948:5;-1:-1:-1;5005:2:13;4990:18;;4977:32;5018:33;4977:32;5018:33;:::i;:::-;5070:7;5060:17;;;4695:388;;;;;:::o;5510:380::-;5589:1;5585:12;;;;5632;;;5653:61;;5707:4;5699:6;5695:17;5685:27;;5653:61;5760:2;5752:6;5749:14;5729:18;5726:38;5723:161;;5806:10;5801:3;5797:20;5794:1;5787:31;5841:4;5838:1;5831:15;5869:4;5866:1;5859:15;5895:127;5956:10;5951:3;5947:20;5944:1;5937:31;5987:4;5984:1;5977:15;6011:4;6008:1;6001:15;6027:128;6094:9;;;6115:11;;;6112:37;;;6129:18;;:::i;7186:277::-;7253:6;7306:2;7294:9;7285:7;7281:23;7277:32;7274:52;;;7322:1;7319;7312:12;7274:52;7354:9;7348:16;7407:5;7400:13;7393:21;7386:5;7383:32;7373:60;;7429:1;7426;7419:12;7468:125;7533:9;;;7554:10;;;7551:36;;;7567:18;;:::i;8261:168::-;8334:9;;;8365;;8382:15;;;8376:22;;8362:37;8352:71;;8403:18;;:::i;8434:127::-;8495:10;8490:3;8486:20;8483:1;8476:31;8526:4;8523:1;8516:15;8550:4;8547:1;8540:15;8566:217;8606:1;8632;8622:132;;8676:10;8671:3;8667:20;8664:1;8657:31;8711:4;8708:1;8701:15;8739:4;8736:1;8729:15;8622:132;-1:-1:-1;8768:9:13;;8566:217::o;9210:375::-;9298:1;9316:5;9330:249;9351:1;9341:8;9338:15;9330:249;;;9401:4;9396:3;9392:14;9386:4;9383:24;9380:50;;;9410:18;;:::i;:::-;9460:1;9450:8;9446:16;9443:49;;;9474:16;;;;9443:49;9557:1;9553:16;;;;;9513:15;;9330:249;;;9210:375;;;;;;:::o;9590:902::-;9639:5;9669:8;9659:80;;-1:-1:-1;9710:1:13;9724:5;;9659:80;9758:4;9748:76;;-1:-1:-1;9795:1:13;9809:5;;9748:76;9840:4;9858:1;9853:59;;;;9926:1;9921:174;;;;9833:262;;9853:59;9883:1;9874:10;;9897:5;;;9921:174;9958:3;9948:8;9945:17;9942:43;;;9965:18;;:::i;:::-;-1:-1:-1;;10021:1:13;10007:16;;10080:5;;9833:262;;10179:2;10169:8;10166:16;10160:3;10154:4;10151:13;10147:36;10141:2;10131:8;10128:16;10123:2;10117:4;10114:12;10110:35;10107:77;10104:203;;;-1:-1:-1;10216:19:13;;;10292:5;;10104:203;10339:42;-1:-1:-1;;10364:8:13;10358:4;10339:42;:::i;:::-;10417:6;10413:1;10409:6;10405:19;10396:7;10393:32;10390:58;;;10428:18;;:::i;:::-;10466:20;;9590:902;-1:-1:-1;;;9590:902:13:o;10497:131::-;10557:5;10586:36;10613:8;10607:4;10586:36;:::i;10633:251::-;10703:6;10756:2;10744:9;10735:7;10731:23;10727:32;10724:52;;;10772:1;10769;10762:12;10724:52;10804:9;10798:16;10823:31;10848:5;10823:31;:::i;10889:127::-;10950:10;10945:3;10941:20;10938:1;10931:31;10981:4;10978:1;10971:15;11005:4;11002:1;10995:15;11021:916;11101:6;11154:2;11142:9;11133:7;11129:23;11125:32;11122:52;;;11170:1;11167;11160:12;11122:52;11203:9;11197:16;11236:18;11228:6;11225:30;11222:50;;;11268:1;11265;11258:12;11222:50;11291:22;;11344:4;11336:13;;11332:27;-1:-1:-1;11322:55:13;;11373:1;11370;11363:12;11322:55;11406:2;11400:9;11432:18;11424:6;11421:30;11418:56;;;11454:18;;:::i;:::-;11503:2;11497:9;11595:2;11557:17;;-1:-1:-1;;11553:31:13;;;11586:2;11549:40;11545:54;11533:67;;11630:18;11615:34;;11651:22;;;11612:62;11609:88;;;11677:18;;:::i;:::-;11713:2;11706:22;11737;;;11778:15;;;11795:2;11774:24;11771:37;-1:-1:-1;11768:57:13;;;11821:1;11818;11811:12;11768:57;11834:72;11899:6;11894:2;11886:6;11882:15;11877:2;11873;11869:11;11834:72;:::i;:::-;11925:6;11021:916;-1:-1:-1;;;;;11021:916:13:o","linkReferences":{},"immutableReferences":{"4546":[{"start":1415,"length":32},{"start":4504,"length":32},{"start":4583,"length":32},{"start":4769,"length":32}],"4548":[{"start":998,"length":32},{"start":4471,"length":32}],"4788":[{"start":1552,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"BSC_MAINNET_CODE_HASH()","signatureHash4":"0x9625baf0","signatureHash32":"0x9625baf0e7e0cdc81c737415dba682eebbd0af870f4930deda09e80bc39febdb"},{"signature":"BSC_MAINNET_REGISTRY()","signatureHash4":"0x91ceed74","signatureHash32":"0x91ceed74a2aa57954f429e17246511fa090e42490c7f23d33b5f242de57780f2"},{"signature":"BURN_ADDRESS()","signatureHash4":"0xfccc2813","signatureHash32":"0xfccc2813187781454f70246172d2f5cf5b67ec9c2d5a0211c5c267bb97ee1750"},{"signature":"BURN_PERCENT()","signatureHash4":"0x9c986764","signatureHash32":"0x9c986764563a775242dd2fe6a52b8b37a9dc7cf42afca30c4c899248b0e96b41"},{"signature":"challenge(address,uint256)","signatureHash4":"0xacb99828","signatureHash32":"0xacb998280b72b501923af214a5c9b117c50bee4e962983c54172efe1f2887d98"},{"signature":"currentGrossReward()","signatureHash4":"0xae7a74f1","signatureHash32":"0xae7a74f1fd073f8643d3488bf69576e6ee7681db788404e35fdc77bd93950099"},{"signature":"currentReward()","signatureHash4":"0x07621eca","signatureHash32":"0x07621ecaeb3aeff204165b3a9a2975963624d90220885fccfe997686d1d18d22"},{"signature":"currentRewardStage()","signatureHash4":"0xf3d77883","signatureHash32":"0xf3d7788346bd10fb5417f272ad0fd9041b7be04a3c9c922acd94732b88a5b80a"},{"signature":"currentStage()","signatureHash4":"0x5bf5d54c","signatureHash32":"0x5bf5d54c94e911485af7f6d0caff58a4e484e1f8e27b31be4b09e20c6400a9fd"},{"signature":"currentTarget()","signatureHash4":"0x39148c53","signatureHash32":"0x39148c53e24e7aaede40373fc289520e407fb0052d520b9ba383c7663de57828"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"dev()","signatureHash4":"0x91cca3db","signatureHash32":"0x91cca3dbe957cc044f247ad281b0abeb12498d7bdd4f2bee014aebb1d864ff4b"},{"signature":"DIFFICULTY_DENOMINATOR()","signatureHash4":"0x1fa4e365","signatureHash32":"0x1fa4e365cae158d4bef1b05511f7a80e9187e7676263e28f034a20ed60d3f8d2"},{"signature":"DIFFICULTY_NUMERATOR()","signatureHash4":"0x3a42b6ea","signatureHash32":"0x3a42b6ea167c7caec3717fe6cdce5a8034a76d9abac76e09a60f83ce222e51e9"},{"signature":"INITIAL_REWARD()","signatureHash4":"0x36bcf7d6","signatureHash32":"0x36bcf7d697370ec5a158737054817777a71d9e377183fb691047cb1c59955da6"},{"signature":"isLive()","signatureHash4":"0xb8f7a665","signatureHash32":"0xb8f7a66579fc6e5fed3f7e9bab22969aa8c5441113559193f99582f81e4e8306"},{"signature":"isOwner(address,uint256)","signatureHash4":"0xe327a6af","signatureHash32":"0xe327a6af0e8741beff017111ae2a844fe3d5019213948b794ca0ab56b58c13b9"},{"signature":"lastProof(address)","signatureHash4":"0xd20442a6","signatureHash32":"0xd20442a6c665b070820b9deba9bb2fb5fb399692358571e2cc4148032b976f0b"},{"signature":"LIQUIDITY_SUPPLY()","signatureHash4":"0x3272f505","signatureHash32":"0x3272f50596833d26645bf8abd4ab412343c091b2b4e7d6011b06b0517c102414"},{"signature":"MAX_REWARD_STAGE()","signatureHash4":"0x3044f40e","signatureHash32":"0x3044f40ee71644a6903af24906e494be926697792b35986e5b852f25b0476dab"},{"signature":"MAX_STAGE()","signatureHash4":"0x3ea92d73","signatureHash32":"0x3ea92d739955b2adc55b08550a8ae2e1de17151bf5cec91ff3d02dd42ec90a7b"},{"signature":"MAX_SUPPLY()","signatureHash4":"0x32cb6b0c","signatureHash32":"0x32cb6b0c9d125b1472513cbeeb7f75e981364c137d7d7140f52eb5e4e9cbb979"},{"signature":"mine(uint256,uint256,uint256,uint256)","signatureHash4":"0x7b7c01be","signatureHash32":"0x7b7c01bea74602008c7f2e6ed067ca9c36f6c9e2d048f7a991c3cff202c57f53"},{"signature":"miningIssued()","signatureHash4":"0x938533db","signatureHash32":"0x938533db75aa11be42312706107dc27a2133deed7490bb9b4ae792782372fd9c"},{"signature":"miningMinted()","signatureHash4":"0x4757b603","signatureHash32":"0x4757b603c0880bbec45077afaea86b5765495efc30f411dc52bb040f00c62989"},{"signature":"MINING_SUPPLY()","signatureHash4":"0xbf417b9f","signatureHash32":"0xbf417b9f5c3f30bf8089782ca01e305cfd20a893de37909305adda955e94f700"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"paused()","signatureHash4":"0x5c975abb","signatureHash32":"0x5c975abbf8c4d6efa68fc896e233763eb503f2318260b7bf59b19412913788b2"},{"signature":"pauseMining()","signatureHash4":"0x162f986d","signatureHash32":"0x162f986d3d710b4808f17c96cd58ee3e0711708519a118af98c470320d68ed57"},{"signature":"proofDigest(address,uint256)","signatureHash4":"0xfd76c4eb","signatureHash32":"0xfd76c4ebab8ca016689dc6ea6d8006cc8e0a4fd4fdf281d5943bbee75e6dbf6a"},{"signature":"publicChallenge()","signatureHash4":"0x04232b3b","signatureHash32":"0x04232b3b32b8c3879981eebd21507208cd2dca7772dfd107bfa8901d512526d0"},{"signature":"puzzleSeed(address)","signatureHash4":"0xd2e3ae76","signatureHash32":"0xd2e3ae76fea595291c5a9ff47d53dc549fd82ed0bfa5a1b40cf7a478dfd5e3d4"},{"signature":"PUZZLE_VERSION()","signatureHash4":"0x4055e7eb","signatureHash32":"0x4055e7ebc3c60fd085ee189234248aca43b9ca8c5ac872cb7df7e447148c5546"},{"signature":"registry()","signatureHash4":"0x7b103999","signatureHash32":"0x7b103999fc1cd0facbe4493f8316b30e59919b2d762e40147ced34e95799db04"},{"signature":"registryCodeHash()","signatureHash4":"0x0843f3c3","signatureHash32":"0x0843f3c3e197a9c8887a84acbe1d20d1e6b727436bb94c8e5625837883664341"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"resumeMining()","signatureHash4":"0x427534a4","signatureHash32":"0x427534a4622419830e91b27f912b433ef73b902d776ec9a84beba262f569279d"},{"signature":"rewardForStage(uint256)","signatureHash4":"0x8c6be17c","signatureHash32":"0x8c6be17c89e3bc093c67a9d676202e16b4c9c7e8ce51e86ce77e176c73760c6c"},{"signature":"rewardStageForIssued(uint256)","signatureHash4":"0x8fc12529","signatureHash32":"0x8fc12529540ba4bbd0632cf655645b40acc3135b0f11104e6edb8ee58f0349b5"},{"signature":"REWARD_STEP_SUPPLY()","signatureHash4":"0x355d34e5","signatureHash32":"0x355d34e54d5d9397ba78cd360f08e118efe16c3ea6affc124ca6b1c9642fcaaa"},{"signature":"rounds(address)","signatureHash4":"0x60b127eb","signatureHash32":"0x60b127eb0defd10ff4bf1fa8312c148540b5492455b3d66f79cc5610d2b66519"},{"signature":"stageForIssued(uint256)","signatureHash4":"0xee6820d1","signatureHash32":"0xee6820d1b0cac92cd95c1b0254f2e0105fd40d02a5bb8b0b064d4aada852ff8b"},{"signature":"STAGE_SUPPLY()","signatureHash4":"0xdb6b2e59","signatureHash32":"0xdb6b2e59ec23940edb45e199f4d3906fbf74ef9d278a244c3088c8391dc2df0b"},{"signature":"startMining()","signatureHash4":"0x21b79d98","signatureHash32":"0x21b79d986d1916173a4d8fcbf4f0ca1abfb0f75706ff4feb1a5bd03142c3246b"},{"signature":"startsAt()","signatureHash4":"0xaf468682","signatureHash32":"0xaf4686828d01b092062e98172a799e1c25928742d9f404844093e56f2c9a9141"},{"signature":"successfulProofs()","signatureHash4":"0x4b21d2cb","signatureHash32":"0x4b21d2cb16b929dbaf19f8cb3dd47129a42997574887edf8fcba7c90958aa64b"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"targetForStage(uint256)","signatureHash4":"0xdcaad5a4","signatureHash32":"0xdcaad5a4c5a0cf921b158cf8d80c69957fddedcb6b92292b78dc3d8e97bfa0e8"},{"signature":"taskSeed()","signatureHash4":"0xbad4ec15","signatureHash32":"0xbad4ec1525cc36255aa642bb69d517e0edf49ca6bab5e6d8260623d109575218"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"usedProofs(bytes32)","signatureHash4":"0xc30a0f25","signatureHash32":"0xc30a0f259da17277dc4001eb933b8203d2ee56aea9cebdb598b5cc7ba172e610"},{"signature":"WORK_BITS()","signatureHash4":"0xcde4e903","signatureHash32":"0xcde4e903bdd310212e90b96f1a5f82670084d7cd5632bf536c0c3ff6691765f0"},{"signature":"WORK_TARGET()","signatureHash4":"0xfb56fee6","signatureHash32":"0xfb56fee6a48d5f95da5b39fd4123d74f094e699983d123c80bba4fb66fe2ac5a"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"DifficultyStageReached(uint256,uint256,uint256)","signatureHash4":"0xc831d30b","signatureHash32":"0xc831d30b9da501d130d6d765fa0e03c644579efbe4b43810b90639abb3ea1a8f"},{"signature":"Mined(address,uint256,bytes32,uint256,uint256,uint256)","signatureHash4":"0xbf3fc84d","signatureHash32":"0xbf3fc84d3727e2674940a192b38f04dcfd0573fdf1cf3b7fce957c9933ad858b"},{"signature":"MiningStarted(uint256,bytes32)","signatureHash4":"0x994f36af","signatureHash32":"0x994f36af7f81eb1185a1e2ec4a202b09e2a0753583e518b5324b1355e7c8f94b"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"Paused(address)","signatureHash4":"0x62e78cea","signatureHash32":"0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"},{"signature":"Unpaused(address)","signatureHash4":"0x5db9ee0a","signatureHash32":"0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa"}],"error":[{"signature":"EnforcedPause()","signatureHash4":"0xd93c0665","signatureHash32":"0xd93c0665d6c96d04a8f174024fc4ddd66c250604aff22bbec808de86dd3637e3"},{"signature":"ERC20InsufficientAllowance(address,uint256,uint256)","signatureHash4":"0xfb8f41b2","signatureHash32":"0xfb8f41b23e99d2101d86da76cdfa87dd51c82ed07d3cb62cbc473e469dbc75c3"},{"signature":"ERC20InsufficientBalance(address,uint256,uint256)","signatureHash4":"0xe450d38c","signatureHash32":"0xe450d38cd8d9f7d95077d567d60ed49c7254716e6ad08fc9872816c97e0ffec6"},{"signature":"ERC20InvalidApprover(address)","signatureHash4":"0xe602df05","signatureHash32":"0xe602df05cc75712490294c6c104ab7c17f4030363910a7a2626411c6d3118847"},{"signature":"ERC20InvalidReceiver(address)","signatureHash4":"0xec442f05","signatureHash32":"0xec442f055133b72f3b2f9f0bb351c406b178527de2040a7d1feb4e058771f613"},{"signature":"ERC20InvalidSender(address)","signatureHash4":"0x96c6fd1e","signatureHash32":"0x96c6fd1edd0cd6ef7ff0ecc0facdf53148dc0048b57fe58af65755250a7a96bd"},{"signature":"ERC20InvalidSpender(address)","signatureHash4":"0x94280d62","signatureHash32":"0x94280d62c347d8d9f4d59a76ea321452406db88df38e0c9da304f58b57b373a2"},{"signature":"ExpectedPause()","signatureHash4":"0x8dfc202b","signatureHash32":"0x8dfc202bcfe9a735b559bee70674422512bc5c30f687046ae8778315fb81da44"},{"signature":"InvalidIdentity()","signatureHash4":"0x178423dd","signatureHash32":"0x178423dd9a18f66c942052940325e5705d5f809b1bb3400da599c6bd9fbc3e17"},{"signature":"InvalidSolution()","signatureHash4":"0xd9c1988f","signatureHash32":"0xd9c1988f945157969c4c62aefe4ff250eb496c6f15e86ffd31a952eb4e2005ba"},{"signature":"InvalidStage()","signatureHash4":"0xe82a5329","signatureHash32":"0xe82a532973694485c89ce150fd170bfffe370bde767bb0e2f878472f0188f60a"},{"signature":"MiningAlreadyStarted()","signatureHash4":"0x6d5d3b18","signatureHash32":"0x6d5d3b18d670ef62891f533d568ff7c5315a037c2665d54a95730704d2763298"},{"signature":"MiningFinished()","signatureHash4":"0x8a7d2016","signatureHash32":"0x8a7d201607dcf76001062744d058817d8ffc84781e0f94e3ca8f86e2833d59c4"},{"signature":"MiningNotStarted()","signatureHash4":"0xefdc789e","signatureHash32":"0xefdc789e4bffec43a0ae4db7f0cc69e00d9023c25e50fdb02782c47e7f976376"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"},{"signature":"OwnershipRenunciationDisabled()","signatureHash4":"0x43a0f09c","signatureHash32":"0x43a0f09c40c1db87ced3efc229c1b38cf794b75ecc9d7885d5349aa3b9f64537"},{"signature":"ProofAlreadyUsed()","signatureHash4":"0xc9838a65","signatureHash32":"0xc9838a653e522fd496d34dd47578b2e3e32c0622fd254ba95a90268d917bd9be"},{"signature":"RewardChanged()","signatureHash4":"0x577742ca","signatureHash32":"0x577742cad9e99ef1b27435ef8b725514b476813893fbbd46e2b818378f503b63"},{"signature":"WrongRound()","signatureHash4":"0xc3fa7054","signatureHash32":"0xc3fa70541cb906246361739f32410426aa8f5d41393a85ae7f57530a1115f70e"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0x6C3b11Dd8d51eA373c3cDbed6c6E51f0d198f81d"}