{"matchId":"43720508","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-08-17T11:22:54Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"56438:3783:0:-:0;;;56544:75;;;-1:-1:-1;;;;;;56544:75:0;;;56577:42;56544:75;;;;56702:43;;;;;;56738:6;56702:43;;;56809:1;56785:25;;;;56817:26;;57081:519;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9259:113;;;;;;;;;;;;-1:-1:-1;;;9259:113:0;;;;;;;;;;;;;;;;;;;;;;;;9325:13;9259:113;;9325:13;:::i;:::-;-1:-1:-1;9348:7:0;:17;9358:7;9348;:17;:::i;:::-;;9259:113;;2107:32;2126:12;:10;;;:12;;:::i;:::-;2107:18;:32::i;:::-;57160:8:::1;:20:::0;;-1:-1:-1;;;;;57160:20:0;;::::1;-1:-1:-1::0;;;;;;57160:20:0;;::::1;;::::0;;;57191:15:::1;:25:::0;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;57298:45:::1;::::0;;-1:-1:-1;;;57298:45:0;;;;:43:::1;::::0;:45:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;57191:25;57298:45:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57371:8;::::0;57280:100:::1;::::0;-1:-1:-1;;;57280:100:0;;57364:4:::1;57280:100;::::0;::::1;3640:34:1::0;-1:-1:-1;;;;;57371:8:0;;::::1;3690:18:1::0;;;3683:43;57280:75:0;::::1;::::0;::::1;::::0;3575:18:1;;57280:100:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57261:16;:119:::0;;-1:-1:-1;;;;;;57261:119:0::1;-1:-1:-1::0;;;;;57261:119:0;;;::::1;::::0;;::::1;::::0;;57401:61:::1;::::0;-1:-1:-1;57401:28:0::1;:61::i;:::-;57477:9;:24:::0;;-1:-1:-1;;;;;;57477:24:0::1;920:10:::0;57477:24:::1;::::0;;2444:6;;57532:2:::1;::::0;57545:47:::1;::::0;-1:-1:-1;;;;;2444:6:0;;57576:15:::1;::::0;57532:2;;57576:15:::1;:::i;:::-;57560:31;::::0;:13:::1;:31;:::i;:::-;57545:5;:47::i;:::-;57149:451;57081:519:::0;;56438:3783;;841:96;920:10;;841:96::o;3597:187::-;3689:6;;;-1:-1:-1;;;;;3705:17:0;;;-1:-1:-1;;;;;;3705:17:0;;;;;;;3737:40;;3689:6;;;3705:17;3689:6;;3737:40;;3670:16;;3737:40;3660:124;3597:187;:::o;57610:254::-;-1:-1:-1;;;;;57702:31:0;;;;;;:25;:31;;;;;;:40;;;:31;;;;:40;;;57694:112;;;;-1:-1:-1;;;57694:112:0;;5627:2:1;57694:112:0;;;5609:21:1;5666:2;5646:18;;;5639:30;5705:34;5685:18;;;5678:62;5776:29;5756:18;;;5749:57;5823:19;;57694:112:0;;;;;;;;;-1:-1:-1;;;;;57817:31:0;;;;;;;;:25;:31;;;;;:39;;-1:-1:-1;;57817:39:0;;;;;;;;;;57610:254::o;15799:535::-;-1:-1:-1;;;;;15882:21:0;;15874:65;;;;-1:-1:-1;;;15874:65:0;;6055:2:1;15874:65:0;;;6037:21:1;6094:2;6074:18;;;6067:30;6133:33;6113:18;;;6106:61;6184:18;;15874:65:0;5853:355:1;15874:65:0;16026:6;16010:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;16178:18:0;;:9;:18;;;;;;;;;;;:28;;;;;;16231:37;6489:25:1;;;16231:37:0;;6462:18:1;16231:37:0;;;;;;;15799:535;;:::o;19352:91::-;;;;:::o;14:177:1:-;93:13;;-1:-1:-1;;;;;135:31:1;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;494:127::-;555:10;550:3;546:20;543:1;536:31;586:4;583:1;576:15;610:4;607:1;600:15;626:380;705:1;701:12;;;;748;;;769:61;;823:4;815:6;811:17;801:27;;769:61;876:2;868:6;865:14;845:18;842:38;839:161;;922:10;917:3;913:20;910:1;903:31;957:4;954:1;947:15;985:4;982:1;975:15;839:161;;626:380;;;:::o;1137:545::-;1239:2;1234:3;1231:11;1228:448;;;1275:1;1300:5;1296:2;1289:17;1345:4;1341:2;1331:19;1415:2;1403:10;1399:19;1396:1;1392:27;1386:4;1382:38;1451:4;1439:10;1436:20;1433:47;;;-1:-1:-1;1474:4:1;1433:47;1529:2;1524:3;1520:12;1517:1;1513:20;1507:4;1503:31;1493:41;;1584:82;1602:2;1595:5;1592:13;1584:82;;;1647:17;;;1628:1;1617:13;1584:82;;;1588:3;;;1137:545;;;:::o;1858:1352::-;1978:10;;-1:-1:-1;;;;;2000:30:1;;1997:56;;;2033:18;;:::i;:::-;2062:97;2152:6;2112:38;2144:4;2138:11;2112:38;:::i;:::-;2106:4;2062:97;:::i;:::-;2214:4;;2278:2;2267:14;;2295:1;2290:663;;;;2997:1;3014:6;3011:89;;;-1:-1:-1;3066:19:1;;;3060:26;3011:89;-1:-1:-1;;1815:1:1;1811:11;;;1807:24;1803:29;1793:40;1839:1;1835:11;;;1790:57;3113:81;;2260:944;;2290:663;1084:1;1077:14;;;1121:4;1108:18;;-1:-1:-1;;2326:20:1;;;2444:236;2458:7;2455:1;2452:14;2444:236;;;2547:19;;;2541:26;2526:42;;2639:27;;;;2607:1;2595:14;;;;2474:19;;2444:236;;;2448:3;2708:6;2699:7;2696:19;2693:201;;;2769:19;;;2763:26;-1:-1:-1;;2852:1:1;2848:14;;;2864:3;2844:24;2840:37;2836:42;2821:58;2806:74;;2693:201;-1:-1:-1;;;;;2940:1:1;2924:14;;;2920:22;2907:36;;-1:-1:-1;1858:1352:1:o;3215:208::-;3285:6;3338:2;3326:9;3317:7;3313:23;3309:32;3306:52;;;3354:1;3351;3344:12;3306:52;3377:40;3407:9;3377:40;:::i;:::-;3367:50;3215:208;-1:-1:-1;;;3215:208:1:o;3737:127::-;3798:10;3793:3;3789:20;3786:1;3779:31;3829:4;3826:1;3819:15;3853:4;3850:1;3843:15;3869:422;3958:1;4001:5;3958:1;4015:270;4036:7;4026:8;4023:21;4015:270;;;4095:4;4091:1;4087:6;4083:17;4077:4;4074:27;4071:53;;;4104:18;;:::i;:::-;4154:7;4144:8;4140:22;4137:55;;;4174:16;;;;4137:55;4253:22;;;;4213:15;;;;4015:270;;;4019:3;3869:422;;;;;:::o;4296:806::-;4345:5;4375:8;4365:80;;-1:-1:-1;4416:1:1;4430:5;;4365:80;4464:4;4454:76;;-1:-1:-1;4501:1:1;4515:5;;4454:76;4546:4;4564:1;4559:59;;;;4632:1;4627:130;;;;4539:218;;4559:59;4589:1;4580:10;;4603:5;;;4627:130;4664:3;4654:8;4651:17;4648:43;;;4671:18;;:::i;:::-;-1:-1:-1;;4727:1:1;4713:16;;4742:5;;4539:218;;4841:2;4831:8;4828:16;4822:3;4816:4;4813:13;4809:36;4803:2;4793:8;4790:16;4785:2;4779:4;4776:12;4772:35;4769:77;4766:159;;;-1:-1:-1;4878:19:1;;;4910:5;;4766:159;4957:34;4982:8;4976:4;4957:34;:::i;:::-;5027:6;5023:1;5019:6;5015:19;5006:7;5003:32;5000:58;;;5038:18;;:::i;:::-;5076:20;;-1:-1:-1;4296:806:1;;;;;:::o;5107:140::-;5165:5;5194:47;5235:4;5225:8;5221:19;5215:4;5194:47;:::i;5252:168::-;5325:9;;;5356;;5373:15;;;5367:22;;5353:37;5343:71;;5394:18;;:::i;6213:125::-;6278:9;;;6299:10;;;6296:36;;;6312:18;;:::i;6343:177::-;56438:3783:0;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220d334d10eadcb899f3a889e421d0efd86476d05715c492edce234d50988888f5364736f6c63430008120033","offset":7835}},"transformations":[{"id":"1","type":"replace","offset":7835,"reason":"cborAuxdata"},{"type":"insert","offset":7888,"reason":"constructorArguments"}],"transformationValues":{"cborAuxdata":{"1":"0xa26469706673582212203f56567b868a29f3d3d074f58c4a146293390ffb65e0a1b13c3f7c7b31d8b22964736f6c63430008120033"},"constructorArguments":"0x00000000000000000000000010ed43c718714eb63d5aa57b78b54704e256024e000000000000000000000000c0dc449de632586a00409873521afc251ac5ce74"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"56438:3783:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9437:98;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11723:197;;;;;;;;;;-1:-1:-1;11723:197:0;;;;;:::i;:::-;;:::i;:::-;;;1272:14:1;;1265:22;1247:41;;1235:2;1220:18;11723:197:0;1107:187:1;56544:75:0;;;;;;;;;;-1:-1:-1;56544:75:0;;;;-1:-1:-1;;;;;56544:75:0;;;;;;-1:-1:-1;;;;;1463:32:1;;;1445:51;;1433:2;1418:18;56544:75:0;1299:203:1;10534:106:0;;;;;;;;;;-1:-1:-1;10621:12:0;;10534:106;;;1653:25:1;;;1641:2;1626:18;10534:106:0;1507:177:1;56850:25:0;;;;;;;;;;-1:-1:-1;56850:25:0;;;;-1:-1:-1;;;;;56850:25:0;;;12482:256;;;;;;;;;;-1:-1:-1;12482:256:0;;;;;:::i;:::-;;:::i;56785:25::-;;;;;;;;;;;;;;;;56882:26;;;;;;;;;;-1:-1:-1;56882:26:0;;;;-1:-1:-1;;;;;56882:26:0;;;10383:91;;;;;;;;;;-1:-1:-1;10383:91:0;;10465:2;2164:36:1;;2152:2;2137:18;10383:91:0;2022:184:1;13133:234:0;;;;;;;;;;-1:-1:-1;13133:234:0;;;;;:::i;:::-;;:::i;58192:200::-;;;;;;;;;;-1:-1:-1;58192:200:0;;;;;:::i;:::-;;:::i;:::-;;58400:311;;;;;;;;;;-1:-1:-1;58400:311:0;;;;;:::i;:::-;;:::i;10698:125::-;;;;;;;;;;-1:-1:-1;10698:125:0;;;;;:::i;:::-;-1:-1:-1;;;;;10798:18:0;10772:7;10798:18;;;;;;;;;;;;10698:125;2995:101;;;;;;;;;;;;;:::i;56672:23::-;;;;;;;;;;-1:-1:-1;56672:23:0;;;;-1:-1:-1;;;;;56672:23:0;;;56702:43;;;;;;;;;;-1:-1:-1;56702:43:0;;;;-1:-1:-1;;;;;56702:43:0;;;2372:85;;;;;;;;;;-1:-1:-1;2444:6:0;;-1:-1:-1;;;;;2444:6:0;2372:85;;56752:24;;;;;;;;;;-1:-1:-1;56752:24:0;;;;-1:-1:-1;;;;;56752:24:0;;;56626:31;;;;;;;;;;-1:-1:-1;56626:31:0;;;;-1:-1:-1;;;;;56626:31:0;;;9648:102;;;;;;;;;;;;;:::i;57900:284::-;;;;;;;;;;-1:-1:-1;57900:284:0;;;;;:::i;:::-;;:::i;13854:427::-;;;;;;;;;;-1:-1:-1;13854:427:0;;;;;:::i;:::-;;:::i;11019:189::-;;;;;;;;;;-1:-1:-1;11019:189:0;;;;;:::i;:::-;;:::i;56978:57::-;;;;;;;;;;-1:-1:-1;56978:57:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;11266:149;;;;;;;;;;-1:-1:-1;11266:149:0;;;;;:::i;:::-;;:::i;3245:198::-;;;;;;;;;;-1:-1:-1;3245:198:0;;;;;:::i;:::-;;:::i;56817:26::-;;;;;;;;;;;;;;;;59890:299;;;;;;;;;;-1:-1:-1;59890:299:0;;;;;:::i;:::-;;:::i;9437:98::-;9491:13;9523:5;9516:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9437:98;:::o;11723:197::-;11806:4;920:10;11860:32;920:10;11876:7;11885:6;11860:8;:32::i;:::-;11909:4;11902:11;;;11723:197;;;;;:::o;12482:256::-;12579:4;920:10;12635:38;12651:4;920:10;12666:6;12635:15;:38::i;:::-;12683:27;12693:4;12699:2;12703:6;12683:9;:27::i;:::-;-1:-1:-1;12727:4:0;;12482:256;-1:-1:-1;;;;12482:256:0:o;13133:234::-;13221:4;920:10;13275:64;920:10;13291:7;13328:10;13300:25;920:10;13291:7;13300:9;:25::i;:::-;:38;;;;:::i;:::-;13275:8;:64::i;58192:200::-;2265:13;:11;:13::i;:::-;58303:2:::1;58281:18;58291:8:::0;58281:7;:18:::1;:::i;:::-;:24;;58273:55;;;::::0;-1:-1:-1;;;58273:55:0;;4212:2:1;58273:55:0::1;::::0;::::1;4194:21:1::0;4251:2;4231:18;;;4224:30;-1:-1:-1;;;4270:18:1;;;4263:48;4328:18;;58273:55:0::1;;;;;;;;;58339:6;:16:::0;;;;58366:7:::1;:18:::0;58192:200::o;58400:311::-;2265:13;:11;:13::i;:::-;-1:-1:-1;;;;;58504:25:0;::::1;58496:60;;;::::0;-1:-1:-1;;;58496:60:0;;4559:2:1;58496:60:0::1;::::0;::::1;4541:21:1::0;4598:2;4578:18;;;4571:30;-1:-1:-1;;;4617:18:1;;;4610:52;4679:18;;58496:60:0::1;4357:346:1::0;58496:60:0::1;-1:-1:-1::0;;;;;58575:26:0;::::1;58567:62;;;::::0;-1:-1:-1;;;58567:62:0;;4910:2:1;58567:62:0::1;::::0;::::1;4892:21:1::0;4949:2;4929:18;;;4922:30;4988:25;4968:18;;;4961:53;5031:18;;58567:62:0::1;4708:347:1::0;58567:62:0::1;58642:10;:24:::0;;-1:-1:-1;;;;;58642:24:0;;::::1;-1:-1:-1::0;;;;;;58642:24:0;;::::1;;::::0;;;58677:11:::1;:26:::0;;;;;::::1;::::0;::::1;;::::0;;58400:311::o;2995:101::-;2265:13;:11;:13::i;:::-;3059:30:::1;3086:1;3059:18;:30::i;:::-;2995:101::o:0;9648:102::-;9704:13;9736:7;9729:14;;;;;:::i;57900:284::-;2265:13;:11;:13::i;:::-;58021:16:::1;::::0;-1:-1:-1;;;;;58021:16:0;;::::1;58013:24:::0;;::::1;::::0;57991:131:::1;;;::::0;-1:-1:-1;;;57991:131:0;;5262:2:1;57991:131:0::1;::::0;::::1;5244:21:1::0;5301:2;5281:18;;;5274:30;5340:34;5320:18;;;5313:62;5411:27;5391:18;;;5384:55;5456:19;;57991:131:0::1;5060:421:1::0;57991:131:0::1;58135:41;58164:4;58170:5;58135:28;:41::i;:::-;57900:284:::0;;:::o;13854:427::-;13947:4;920:10;13947:4;14028:25;920:10;14045:7;14028:9;:25::i;:::-;14001:52;;14091:15;14071:16;:35;;14063:85;;;;-1:-1:-1;;;14063:85:0;;5688:2:1;14063:85:0;;;5670:21:1;5727:2;5707:18;;;5700:30;5766:34;5746:18;;;5739:62;-1:-1:-1;;;5817:18:1;;;5810:35;5862:19;;14063:85:0;5486:401:1;14063:85:0;14182:60;14191:5;14198:7;14226:15;14207:16;:34;14182:8;:60::i;11019:189::-;11098:4;920:10;11152:28;920:10;11169:2;11173:6;11152:9;:28::i;11266:149::-;-1:-1:-1;;;;;11381:18:0;;;11355:7;11381:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;11266:149::o;3245:198::-;2265:13;:11;:13::i;:::-;-1:-1:-1;;;;;3333:22:0;::::1;3325:73;;;::::0;-1:-1:-1;;;3325:73:0;;6094:2:1;3325:73:0::1;::::0;::::1;6076:21:1::0;6133:2;6113:18;;;6106:30;6172:34;6152:18;;;6145:62;-1:-1:-1;;;6223:18:1;;;6216:36;6269:19;;3325:73:0::1;5892:402:1::0;3325:73:0::1;3408:28;3427:8;3408:18;:28::i;:::-;3245:198:::0;:::o;59890:299::-;59978:9;;59952:60;;-1:-1:-1;;;;;59978:9:0;59990:21;59952:17;:60::i;:::-;-1:-1:-1;;;;;60027:20:0;;;;;;:47;;-1:-1:-1;;;;;;60051:23:0;;60069:4;60051:23;;60027:47;60023:159;;;60119:9;;60130:39;;-1:-1:-1;;;60130:39:0;;60163:4;60130:39;;;1445:51:1;60091:79:0;;-1:-1:-1;;;;;60119:9:0;;;;60130:24;;;;;;1418:18:1;;60130:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;60091:27:0;;;:79;:27;:79::i;17736:340::-;-1:-1:-1;;;;;17837:19:0;;17829:68;;;;-1:-1:-1;;;17829:68:0;;6690:2:1;17829:68:0;;;6672:21:1;6729:2;6709:18;;;6702:30;6768:34;6748:18;;;6741:62;-1:-1:-1;;;6819:18:1;;;6812:34;6863:19;;17829:68:0;6488:400:1;17829:68:0;-1:-1:-1;;;;;17915:21:0;;17907:68;;;;-1:-1:-1;;;17907:68:0;;7095:2:1;17907:68:0;;;7077:21:1;7134:2;7114:18;;;7107:30;7173:34;7153:18;;;7146:62;-1:-1:-1;;;7224:18:1;;;7217:32;7266:19;;17907:68:0;6893:398:1;17907:68:0;-1:-1:-1;;;;;17986:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;18037:32;;1653:25:1;;;18037:32:0;;1626:18:1;18037:32:0;;;;;;;17736:340;;;:::o;18357:411::-;18457:24;18484:25;18494:5;18501:7;18484:9;:25::i;:::-;18457:52;;-1:-1:-1;;18523:16:0;:37;18519:243;;18604:6;18584:16;:26;;18576:68;;;;-1:-1:-1;;;18576:68:0;;7498:2:1;18576:68:0;;;7480:21:1;7537:2;7517:18;;;7510:30;7576:31;7556:18;;;7549:59;7625:18;;18576:68:0;7296:353:1;18576:68:0;18686:51;18695:5;18702:7;18730:6;18711:16;:25;18686:8;:51::i;:::-;18447:321;18357:411;;;:::o;58719:1163::-;-1:-1:-1;;;;;58851:18:0;;58843:68;;;;-1:-1:-1;;;58843:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;58930:16:0;;58922:64;;;;-1:-1:-1;;;58922:64:0;;;;;;;:::i;:::-;59002:6;59012:1;59002:11;58999:92;;59030:28;59046:4;59052:2;59056:1;59030:15;:28::i;:::-;58719:1163;;;:::o;58999:92::-;-1:-1:-1;;;;;59117:29:0;;;59103:11;59117:29;;;:25;:29;;;;;;59182:15;;59117:29;;;;;59174:23;;;59182:15;;59174:23;;:48;;-1:-1:-1;59207:15:0;;-1:-1:-1;;;;;59201:21:0;;;59207:15;;59201:21;59174:48;59157:66;;59240:8;59236:593;;;59264:33;59280:4;59286:2;59290:6;59264:15;:33::i;:::-;59236:593;;;59319:6;59315:514;;;59341:17;59361:27;59384:3;59361:18;59372:6;;59361;:10;;:18;;;;:::i;:::-;:22;;:27::i;:::-;59341:47;;59403:18;59424:28;59448:3;59424:19;59435:7;;59424:6;:10;;:19;;;;:::i;:28::-;59403:49;-1:-1:-1;59490:37:0;59403:49;59490:21;:6;59501:9;59490:10;:21::i;:::-;:25;;:37::i;:::-;59481:46;-1:-1:-1;59571:13:0;;59567:97;;59626:10;;59604:44;;59620:4;;-1:-1:-1;;;;;59626:10:0;59638:9;59604:15;:44::i;:::-;59708:14;;59704:100;;59764:11;;59742:46;;59758:4;;-1:-1:-1;;;;;59764:11:0;59777:10;59742:15;:46::i;:::-;59326:503;;59315:514;59841:33;59857:4;59863:2;59867:6;59841:15;:33::i;:::-;58832:1050;;58719:1163;;;:::o;2530:130::-;2444:6;;-1:-1:-1;;;;;2444:6:0;920:10;2593:23;2585:68;;;;-1:-1:-1;;;2585:68:0;;8666:2:1;2585:68:0;;;8648:21:1;;;8685:18;;;8678:30;8744:34;8724:18;;;8717:62;8796:18;;2585:68:0;8464:356:1;3597:187:0;3689:6;;;-1:-1:-1;;;;;3705:17:0;;;-1:-1:-1;;;;;;3705:17:0;;;;;;;3737:40;;3689:6;;;3705:17;3689:6;;3737:40;;3670:16;;3737:40;3660:124;3597:187;:::o;57610:254::-;-1:-1:-1;;;;;57702:31:0;;;;;;:25;:31;;;;;;:40;;;:31;;;;:40;;;57694:112;;;;-1:-1:-1;;;57694:112:0;;9027:2:1;57694:112:0;;;9009:21:1;9066:2;9046:18;;;9039:30;9105:34;9085:18;;;9078:62;9176:29;9156:18;;;9149:57;9223:19;;57694:112:0;8825:423:1;57694:112:0;-1:-1:-1;;;;;57817:31:0;;;;;;;;:25;:31;;;;;:39;;-1:-1:-1;;57817:39:0;;;;;;;;;;57610:254::o;26703:312::-;26817:6;26792:21;:31;;26784:73;;;;-1:-1:-1;;;26784:73:0;;9455:2:1;26784:73:0;;;9437:21:1;9494:2;9474:18;;;9467:30;9533:31;9513:18;;;9506:59;9582:18;;26784:73:0;9253:353:1;26784:73:0;26869:12;26887:9;-1:-1:-1;;;;;26887:14:0;26909:6;26887:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26868:52;;;26938:7;26930:78;;;;-1:-1:-1;;;26930:78:0;;10023:2:1;26930:78:0;;;10005:21:1;10062:2;10042:18;;;10035:30;10101:34;10081:18;;;10074:62;10172:28;10152:18;;;10145:56;10218:19;;26930:78:0;9821:422:1;34328:175:0;34437:58;;;-1:-1:-1;;;;;10440:32:1;;34437:58:0;;;10422:51:1;10489:18;;;;10482:34;;;34437:58:0;;;;;;;;;;10395:18:1;;;;34437:58:0;;;;;;;;-1:-1:-1;;;;;34437:58:0;-1:-1:-1;;;34437:58:0;;;34410:86;;34430:5;;34410:19;:86::i;14735:788::-;-1:-1:-1;;;;;14831:18:0;;14823:68;;;;-1:-1:-1;;;14823:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;14909:16:0;;14901:64;;;;-1:-1:-1;;;14901:64:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;15047:15:0;;15025:19;15047:15;;;;;;;;;;;15080:21;;;;15072:72;;;;-1:-1:-1;;;15072:72:0;;10729:2:1;15072:72:0;;;10711:21:1;10768:2;10748:18;;;10741:30;10807:34;10787:18;;;10780:62;-1:-1:-1;;;10858:18:1;;;10851:36;10904:19;;15072:72:0;10527:402:1;15072:72:0;-1:-1:-1;;;;;15178:15:0;;;:9;:15;;;;;;;;;;;15196:20;;;15178:38;;15393:13;;;;;;;;;;:23;;;;;;15442:26;;1653:25:1;;;15393:13:0;;15442:26;;1626:18:1;15442:26:0;;;;;;;15479:37;58719:1163;43848:96;43906:7;43932:5;43936:1;43932;:5;:::i;:::-;43925:12;43848:96;-1:-1:-1;;;43848:96:0:o;44233:::-;44291:7;44317:5;44321:1;44317;:5;:::i;43505:96::-;43563:7;43589:5;43593:1;43589;:5;:::i;38583:642::-;39002:23;39028:69;39056:4;39028:69;;;;;;;;;;;;;;;;;39036:5;-1:-1:-1;;;;;39028:27:0;;;:69;;;;;:::i;:::-;39002:95;;39115:10;:17;39136:1;39115:22;:56;;;;39152:10;39141:30;;;;;;;;;;;;:::i;:::-;39107:111;;;;-1:-1:-1;;;39107:111:0;;11914:2:1;39107:111:0;;;11896:21:1;11953:2;11933:18;;;11926:30;11992:34;11972:18;;;11965:62;-1:-1:-1;;;12043:18:1;;;12036:40;12093:19;;39107:111:0;11712:406:1;28164:223:0;28297:12;28328:52;28350:6;28358:4;28364:1;28367:12;28328:21;:52::i;:::-;28321:59;28164:223;-1:-1:-1;;;;28164:223:0:o;29221:446::-;29386:12;29443:5;29418:21;:30;;29410:81;;;;-1:-1:-1;;;29410:81:0;;12325:2:1;29410:81:0;;;12307:21:1;12364:2;12344:18;;;12337:30;12403:34;12383:18;;;12376:62;-1:-1:-1;;;12454:18:1;;;12447:36;12500:19;;29410:81:0;12123:402:1;29410:81:0;29502:12;29516:23;29543:6;-1:-1:-1;;;;;29543:11:0;29562:5;29569:4;29543:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29501:73;;;;29591:69;29618:6;29626:7;29635:10;29647:12;29591:26;:69::i;:::-;29584:76;29221:446;-1:-1:-1;;;;;;;29221:446:0:o;31727:628::-;31907:12;31935:7;31931:418;;;31962:10;:17;31983:1;31962:22;31958:286;;-1:-1:-1;;;;;25758:19:0;;;32169:60;;;;-1:-1:-1;;;32169:60:0;;13024:2:1;32169:60:0;;;13006:21:1;13063:2;13043:18;;;13036:30;13102:31;13082:18;;;13075:59;13151:18;;32169:60:0;12822:353:1;32169:60:0;-1:-1:-1;32264:10:0;32257:17;;31931:418;32305:33;32313:10;32325:12;33036:17;;:21;33032:379;;33264:10;33258:17;33320:15;33307:10;33303:2;33299:19;33292:44;33032:379;33387:12;33380:20;;-1:-1:-1;;;33380:20:0;;;;;;;;:::i;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:396::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;649:2;628:15;-1:-1:-1;;624:29:1;609:45;;;;656:2;605:54;;269:396;-1:-1:-1;;269:396:1:o;670:173::-;738:20;;-1:-1:-1;;;;;787:31:1;;777:42;;767:70;;833:1;830;823:12;767:70;670:173;;;:::o;848:254::-;916:6;924;977:2;965:9;956:7;952:23;948:32;945:52;;;993:1;990;983:12;945:52;1016:29;1035:9;1016:29;:::i;:::-;1006:39;1092:2;1077:18;;;;1064:32;;-1:-1:-1;;;848:254:1:o;1689:328::-;1766:6;1774;1782;1835:2;1823:9;1814:7;1810:23;1806:32;1803:52;;;1851:1;1848;1841:12;1803:52;1874:29;1893:9;1874:29;:::i;:::-;1864:39;;1922:38;1956:2;1945:9;1941:18;1922:38;:::i;:::-;1912:48;;2007:2;1996:9;1992:18;1979:32;1969:42;;1689:328;;;;;:::o;2211:248::-;2279:6;2287;2340:2;2328:9;2319:7;2315:23;2311:32;2308:52;;;2356:1;2353;2346:12;2308:52;-1:-1:-1;;2379:23:1;;;2449:2;2434:18;;;2421:32;;-1:-1:-1;2211:248:1:o;2464:260::-;2532:6;2540;2593:2;2581:9;2572:7;2568:23;2564:32;2561:52;;;2609:1;2606;2599:12;2561:52;2632:29;2651:9;2632:29;:::i;:::-;2622:39;;2680:38;2714:2;2703:9;2699:18;2680:38;:::i;:::-;2670:48;;2464:260;;;;;:::o;2729:186::-;2788:6;2841:2;2829:9;2820:7;2816:23;2812:32;2809:52;;;2857:1;2854;2847:12;2809:52;2880:29;2899:9;2880:29;:::i;2920:118::-;3006:5;2999:13;2992:21;2985:5;2982:32;2972:60;;3028:1;3025;3018:12;3043:315;3108:6;3116;3169:2;3157:9;3148:7;3144:23;3140:32;3137:52;;;3185:1;3182;3175:12;3137:52;3208:29;3227:9;3208:29;:::i;:::-;3198:39;;3287:2;3276:9;3272:18;3259:32;3300:28;3322:5;3300:28;:::i;:::-;3347:5;3337:15;;;3043:315;;;;;:::o;3363:380::-;3442:1;3438:12;;;;3485;;;3506:61;;3560:4;3552:6;3548:17;3538:27;;3506:61;3613:2;3605:6;3602:14;3582:18;3579:38;3576:161;;3659:10;3654:3;3650:20;3647:1;3640:31;3694:4;3691:1;3684:15;3722:4;3719:1;3712:15;3576:161;;3363:380;;;:::o;3748:127::-;3809:10;3804:3;3800:20;3797:1;3790:31;3840:4;3837:1;3830:15;3864:4;3861:1;3854:15;3880:125;3945:9;;;3966:10;;;3963:36;;;3979:18;;:::i;6299:184::-;6369:6;6422:2;6410:9;6401:7;6397:23;6393:32;6390:52;;;6438:1;6435;6428:12;6390:52;-1:-1:-1;6461:16:1;;6299:184;-1:-1:-1;6299:184:1:o;7654:401::-;7856:2;7838:21;;;7895:2;7875:18;;;7868:30;7934:34;7929:2;7914:18;;7907:62;-1:-1:-1;;;8000:2:1;7985:18;;7978:35;8045:3;8030:19;;7654:401::o;8060:399::-;8262:2;8244:21;;;8301:2;8281:18;;;8274:30;8340:34;8335:2;8320:18;;8313:62;-1:-1:-1;;;8406:2:1;8391:18;;8384:33;8449:3;8434:19;;8060:399::o;10934:168::-;11007:9;;;11038;;11055:15;;;11049:22;;11035:37;11025:71;;11076:18;;:::i;11107:217::-;11147:1;11173;11163:132;;11217:10;11212:3;11208:20;11205:1;11198:31;11252:4;11249:1;11242:15;11280:4;11277:1;11270:15;11163:132;-1:-1:-1;11309:9:1;;11107:217::o;11329:128::-;11396:9;;;11417:11;;;11414:37;;;11431:18;;:::i;11462:245::-;11529:6;11582:2;11570:9;11561:7;11557:23;11553:32;11550:52;;;11598:1;11595;11588:12;11550:52;11630:9;11624:16;11649:28;11671:5;11649:28;:::i;12530:287::-;12659:3;12697:6;12691:13;12713:66;12772:6;12767:3;12760:4;12752:6;12748:17;12713:66;:::i;:::-;12795:16;;;;;12530:287;-1:-1:-1;;12530:287:1:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220d334d10eadcb899f3a889e421d0efd86476d05715c492edce234d50988888f5364736f6c63430008120033","offset":5893}},"immutableReferences":{},"transformations":[{"id":"1","type":"replace","offset":5893,"reason":"cborAuxdata"}],"transformationValues":{"cborAuxdata":{"1":"0xa26469706673582212203f56567b868a29f3d3d074f58c4a146293390ffb65e0a1b13c3f7c7b31d8b22964736f6c63430008120033"}}},"deployment":{"transactionHash":"0x6e8ae1c9ef1b60404facb51ac498e4f37510eeb95c1d0a4617cea3be9cac72ea","blockNumber":"104669711","transactionIndex":"20","deployer":"0x13b81C2e8a4EDD2aAc1A096889B778103b16F7e8"},"sources":{"contracts/flatten/nexus_nex.sol":{"content":"// Sources flattened with hardhat v2.28.6 https://hardhat.org\n\n// SPDX-License-Identifier: MIT AND Unlicense\n\n// File @openzeppelin/contracts/utils/Context.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n\n\n// File @openzeppelin/contracts/access/Ownable.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/ERC20.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\n\n\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\n\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n *     doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n *     token.safeTransferFrom(msg.sender, address(this), value);\n *     ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     *\n     * CAUTION: See Security Considerations above.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n\n\n// File @openzeppelin/contracts/utils/Address.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\n\n\n\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    using Address for address;\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    /**\n     * @dev Deprecated. This function has issues similar to the ones found in\n     * {IERC20-approve}, and its usage is discouraged.\n     *\n     * Whenever possible, use {safeIncreaseAllowance} and\n     * {safeDecreaseAllowance} instead.\n     */\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        // safeApprove should only be called when setting an initial allowance,\n        // or when resetting it to zero. To increase and decrease it, use\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n        require(\n            (value == 0) || (token.allowance(address(this), spender) == 0),\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\n        );\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        unchecked {\n            uint256 oldAllowance = token.allowance(address(this), spender);\n            require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\n     * Revert on invalid signature.\n     */\n    function safePermit(\n        IERC20Permit token,\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        uint256 nonceBefore = token.nonces(owner);\n        token.permit(owner, spender, value, deadline, v, r, s);\n        uint256 nonceAfter = token.nonces(owner);\n        require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n        // the target address contains contract code and also asserts for success in the low-level call.\n\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n        // and not revert is the subcall reverts.\n\n        (bool success, bytes memory returndata) = address(token).call(data);\n        return\n            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\n    }\n}\n\n\n// File @openzeppelin/contracts/utils/math/SafeMath.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)\n\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a + b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a * b;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator.\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a % b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {trySub}.\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        unchecked {\n            require(b <= a, errorMessage);\n            return a - b;\n        }\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        unchecked {\n            require(b > 0, errorMessage);\n            return a / b;\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting with custom message when dividing by zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryMod}.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        unchecked {\n            require(b > 0, errorMessage);\n            return a % b;\n        }\n    }\n}\n\n\n// File contracts/interface/IUniswapV2.sol\n\n// Original license: SPDX_License_Identifier: Unlicense\r\n\r\ninterface IUniswapV2Factory {\r\n    event PairCreated(\r\n        address indexed token0,\r\n        address indexed token1,\r\n        address pair,\r\n        uint256\r\n    );\r\n\r\n    function feeTo() external view returns (address);\r\n\r\n    function feeToSetter() external view returns (address);\r\n\r\n    function getPair(\r\n        address tokenA,\r\n        address tokenB\r\n    ) external view returns (address pair);\r\n\r\n    function allPairs(uint256) external view returns (address pair);\r\n\r\n    function allPairsLength() external view returns (uint256);\r\n\r\n    function createPair(\r\n        address tokenA,\r\n        address tokenB\r\n    ) external returns (address pair);\r\n\r\n    function setFeeTo(address) external;\r\n\r\n    function setFeeToSetter(address) external;\r\n}\r\n\r\ninterface IUniswapV2Pair {\r\n    event Approval(\r\n        address indexed owner,\r\n        address indexed spender,\r\n        uint256 value\r\n    );\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n\r\n    function name() external pure returns (string memory);\r\n\r\n    function symbol() external pure returns (string memory);\r\n\r\n    function decimals() external pure returns (uint8);\r\n\r\n    function totalSupply() external view returns (uint256);\r\n\r\n    function balanceOf(address owner) external view returns (uint256);\r\n\r\n    function allowance(\r\n        address owner,\r\n        address spender\r\n    ) external view returns (uint256);\r\n\r\n    function approve(address spender, uint256 value) external returns (bool);\r\n\r\n    function transfer(address to, uint256 value) external returns (bool);\r\n\r\n    function transferFrom(\r\n        address from,\r\n        address to,\r\n        uint256 value\r\n    ) external returns (bool);\r\n\r\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\r\n\r\n    function PERMIT_TYPEHASH() external pure returns (bytes32);\r\n\r\n    function nonces(address owner) external view returns (uint256);\r\n\r\n    function permit(\r\n        address owner,\r\n        address spender,\r\n        uint256 value,\r\n        uint256 deadline,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external;\r\n\r\n    event Mint(address indexed sender, uint256 amount0, uint256 amount1);\r\n    event Burn(\r\n        address indexed sender,\r\n        uint256 amount0,\r\n        uint256 amount1,\r\n        address indexed to\r\n    );\r\n    event Swap(\r\n        address indexed sender,\r\n        uint256 amount0In,\r\n        uint256 amount1In,\r\n        uint256 amount0Out,\r\n        uint256 amount1Out,\r\n        address indexed to\r\n    );\r\n    event Sync(uint112 reserve0, uint112 reserve1);\r\n\r\n    function MINIMUM_LIQUIDITY() external pure returns (uint256);\r\n\r\n    function factory() external view returns (address);\r\n\r\n    function token0() external view returns (address);\r\n\r\n    function token1() external view returns (address);\r\n\r\n    function getReserves()\r\n        external\r\n        view\r\n        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\r\n\r\n    function price0CumulativeLast() external view returns (uint256);\r\n\r\n    function price1CumulativeLast() external view returns (uint256);\r\n\r\n    function kLast() external view returns (uint256);\r\n\r\n    function mint(address to) external returns (uint256 liquidity);\r\n\r\n    function burn(\r\n        address to\r\n    ) external returns (uint256 amount0, uint256 amount1);\r\n\r\n    function swap(\r\n        uint256 amount0Out,\r\n        uint256 amount1Out,\r\n        address to,\r\n        bytes calldata data\r\n    ) external;\r\n\r\n    function skim(address to) external;\r\n\r\n    function sync() external;\r\n\r\n    function initialize(address, address) external;\r\n}\r\n\r\ninterface IUniswapV2Router01 {\r\n    function factory() external pure returns (address);\r\n\r\n    function WETH() external pure returns (address);\r\n\r\n    function addLiquidity(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 amountADesired,\r\n        uint256 amountBDesired,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);\r\n\r\n    function addLiquidityETH(\r\n        address token,\r\n        uint256 amountTokenDesired,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    )\r\n        external\r\n        payable\r\n        returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);\r\n\r\n    function removeLiquidity(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 liquidity,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountA, uint256 amountB);\r\n\r\n    function removeLiquidityETH(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountToken, uint256 amountETH);\r\n\r\n    function removeLiquidityWithPermit(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 liquidity,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountA, uint256 amountB);\r\n\r\n    function removeLiquidityETHWithPermit(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountToken, uint256 amountETH);\r\n\r\n    function swapExactTokensForTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapTokensForExactTokens(\r\n        uint256 amountOut,\r\n        uint256 amountInMax,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapExactETHForTokens(\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable returns (uint256[] memory amounts);\r\n\r\n    function swapTokensForExactETH(\r\n        uint256 amountOut,\r\n        uint256 amountInMax,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapExactTokensForETH(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapETHForExactTokens(\r\n        uint256 amountOut,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable returns (uint256[] memory amounts);\r\n\r\n    function quote(\r\n        uint256 amountA,\r\n        uint256 reserveA,\r\n        uint256 reserveB\r\n    ) external pure returns (uint256 amountB);\r\n\r\n    function getAmountOut(\r\n        uint256 amountIn,\r\n        uint256 reserveIn,\r\n        uint256 reserveOut\r\n    ) external pure returns (uint256 amountOut);\r\n\r\n    function getAmountIn(\r\n        uint256 amountOut,\r\n        uint256 reserveIn,\r\n        uint256 reserveOut\r\n    ) external pure returns (uint256 amountIn);\r\n\r\n    function getAmountsOut(\r\n        uint256 amountIn,\r\n        address[] calldata path\r\n    ) external view returns (uint256[] memory amounts);\r\n\r\n    function getAmountsIn(\r\n        uint256 amountOut,\r\n        address[] calldata path\r\n    ) external view returns (uint256[] memory amounts);\r\n}\r\n\r\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\r\n    function removeLiquidityETHSupportingFeeOnTransferTokens(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountETH);\r\n\r\n    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountETH);\r\n\r\n    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external;\r\n\r\n    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable;\r\n\r\n    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external;\r\n}\n\n\n// File contracts/nexus/1_nex.sol\n\n// Original license: SPDX_License_Identifier: MIT\r\ncontract NEX is ERC20, Ownable {\r\n    using SafeMath for uint256;\r\n    using SafeERC20 for IERC20;\r\n\r\n    address public uniswapV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;\r\n    address public uniswapV2PairAid;\r\n\r\n    \r\n    address public tokenAid;\r\n    address public deadWallet = address(0xdead);\r\n    address public devWallet;\r\n\r\n    uint256 public daoFee = 3;\r\n    uint256 public nodeFee = 3;\r\n    address public daoAddress;\r\n    address public nodeAddress;\r\n\r\n    // store addresses that a automatic market maker pairs.\r\n    mapping(address => bool) public automatedMarketMakerPairs;\r\n\r\n    receive() external payable {}\r\n\r\n    constructor(address _router, address _tokenAid) ERC20(\"NEX\", \"NEX\") {\r\n        tokenAid = _tokenAid;\r\n        uniswapV2Router = _router;\r\n\r\n        // Create uniswap pair\r\n        uniswapV2PairAid = IUniswapV2Factory(IUniswapV2Router02(uniswapV2Router).factory()).createPair(address(this), tokenAid);\r\n        \r\n        _setAutomatedMarketMakerPair(address(uniswapV2PairAid), true);\r\n\r\n\r\n        devWallet = _msgSender();\r\n\r\n        uint8 _decimals = 18;\r\n        _mint(owner(), 1_000_000_000 * 10 ** _decimals);\r\n    }\r\n\r\n\r\n    function _setAutomatedMarketMakerPair(address pair, bool value) internal {\r\n        require(automatedMarketMakerPairs[pair] != value, \" : Automated market maker pair is already set to that value\");\r\n        automatedMarketMakerPairs[pair] = value;\r\n    }\r\n\r\n    /** Admin Functions */\r\n    function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {\r\n        require(\r\n            pair != uniswapV2PairAid,\r\n            \"The pair cannot be removed from automatedMarketMakerPairs\"\r\n        );\r\n\r\n        _setAutomatedMarketMakerPair(pair, value);\r\n    }\r\n\r\n    function setFee(uint256 _daoFee, uint256 _nodeFee) external onlyOwner {\r\n        require(_daoFee + _nodeFee <= 50, \" : Fee is too high\");\r\n        daoFee = _daoFee;\r\n        nodeFee = _nodeFee;\r\n    }\r\n\r\n    function setFeeAddress(address _daoAddress, address _nodeAddress) external onlyOwner {\r\n        require(_daoAddress != address(0), \" : Invalid dao address\");\r\n        require(_nodeAddress != address(0), \" : Invalid node address\");\r\n\r\n        daoAddress = _daoAddress;\r\n        nodeAddress = _nodeAddress;\r\n    }\r\n\r\n    function _transfer(\r\n        address from,\r\n        address to,\r\n        uint256 amount\r\n    ) internal override {\r\n        require(from != address(0), \"ERC20: transfer from the zero address\");\r\n        require(to != address(0), \"ERC20: transfer to the zero address\");\r\n\r\n        if(amount == 0) {\r\n            super._transfer(from, to, 0);\r\n            return;\r\n        }\r\n\r\n        bool isSell = automatedMarketMakerPairs[to];\r\n        bool isRouter = (from == uniswapV2Router || to == uniswapV2Router);\r\n\r\n        if (isRouter){\r\n            super._transfer(from, to, amount);\r\n        } else if (isSell){\r\n            uint256 daoTokens = amount.mul(daoFee).div(100);\r\n            uint256 nodeTokens = amount.mul(nodeFee).div(100);\r\n            \r\n            amount = amount.sub(daoTokens).sub(nodeTokens);\r\n\r\n            // to dao\r\n            if (daoTokens > 0){\r\n                super._transfer(from, daoAddress, daoTokens);\r\n            }\r\n\r\n            // to node\r\n            if (nodeTokens > 0){\r\n                super._transfer(from, nodeAddress, nodeTokens);\r\n            }\r\n            \r\n        }\r\n\r\n        super._transfer(from, to, amount);\r\n    }\r\n\r\n    function claimStuckTokens(address _token) external {\r\n        Address.sendValue(payable(devWallet), address(this).balance);\r\n        if (_token != address(0) && _token != address(this)) {\r\n            IERC20(_token).safeTransfer(devWallet, IERC20(_token).balanceOf(address(this)));\r\n        }\r\n    }\r\n\r\n    /** View Functions */\r\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.18+commit.87f61d96","compilerSettings":{"optimizer":{"runs":200,"enabled":true}},"name":"NEX","fullyQualifiedName":"contracts/flatten/nexus_nex.sol:NEX"},"abi":[{"type":"constructor","inputs":[{"name":"_router","type":"address","internalType":"address"},{"name":"_tokenAid","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"automatedMarketMakerPairs","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claimStuckTokens","type":"function","inputs":[{"name":"_token","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"daoAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"daoFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"deadWallet","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"devWallet","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"nodeAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"nodeFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setAutomatedMarketMakerPair","type":"function","inputs":[{"name":"pair","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setFee","type":"function","inputs":[{"name":"_daoFee","type":"uint256","internalType":"uint256"},{"name":"_nodeFee","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setFeeAddress","type":"function","inputs":[{"name":"_daoAddress","type":"address","internalType":"address"},{"name":"_nodeAddress","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenAid","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"uniswapV2PairAid","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"uniswapV2Router","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.18+commit.87f61d96"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_router","type":"address"},{"internalType":"address","name":"_tokenAid","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"automatedMarketMakerPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"_token","type":"address"}],"name":"claimStuckTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"daoAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"daoFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deadWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nodeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nodeFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_daoFee","type":"uint256"},{"internalType":"uint256","name":"_nodeFee","type":"uint256"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_daoAddress","type":"address"},{"internalType":"address","name":"_nodeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenAid","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2PairAid","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"kind":"dev","methods":{"allowance(address,address)":{"details":"See {IERC20-allowance}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"userdoc":{"kind":"user","methods":{"setAutomatedMarketMakerPair(address,bool)":{"notice":"Admin Functions "}},"version":1}},"settings":{"compilationTarget":{"contracts/flatten/nexus_nex.sol":"NEX"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"contracts/flatten/nexus_nex.sol":{"keccak256":"0xc3d1394fb997f9ac9954c7cb1c1bc32a5147005c685f779a73fdd738629a3d07","license":"MIT AND Unlicense","urls":["bzz-raw://bd3e9fb250ede66d558dcfb66aa126d74cb0c7ebc607d7514d4236c4afd75795","dweb:/ipfs/QmbVr6y5gsvZsNTrWKDDfAmSmUQ4SwSU693D2Lok8Zvp27"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":248,"label":"_balances","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":254,"label":"_allowances","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"2","type":"t_uint256","astId":256,"label":"_totalSupply","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"3","type":"t_string_storage","astId":258,"label":"_name","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"4","type":"t_string_storage","astId":260,"label":"_symbol","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"5","type":"t_address","astId":34,"label":"_owner","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"6","type":"t_address","astId":2568,"label":"uniswapV2Router","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"7","type":"t_address","astId":2570,"label":"uniswapV2PairAid","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"8","type":"t_address","astId":2572,"label":"tokenAid","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"9","type":"t_address","astId":2578,"label":"deadWallet","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"10","type":"t_address","astId":2580,"label":"devWallet","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"11","type":"t_uint256","astId":2583,"label":"daoFee","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"12","type":"t_uint256","astId":2586,"label":"nodeFee","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"13","type":"t_address","astId":2588,"label":"daoAddress","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"14","type":"t_address","astId":2590,"label":"nodeAddress","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"15","type":"t_mapping(t_address,t_bool)","astId":2594,"label":"automatedMarketMakerPairs","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{"setAutomatedMarketMakerPair(address,bool)":{"notice":"Admin Functions "}},"version":1},"devdoc":{"kind":"dev","events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"sourceIds":{"contracts/flatten/nexus_nex.sol":{"id":0}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/flatten/nexus_nex.sol":{"content":"// Sources flattened with hardhat v2.28.6 https://hardhat.org\n\n// SPDX-License-Identifier: MIT AND Unlicense\n\n// File @openzeppelin/contracts/utils/Context.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n\n\n// File @openzeppelin/contracts/access/Ownable.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/ERC20.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\n\n\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\n\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n *     doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n *     token.safeTransferFrom(msg.sender, address(this), value);\n *     ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     *\n     * CAUTION: See Security Considerations above.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n\n\n// File @openzeppelin/contracts/utils/Address.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n\n\n// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\n\n\n\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    using Address for address;\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    /**\n     * @dev Deprecated. This function has issues similar to the ones found in\n     * {IERC20-approve}, and its usage is discouraged.\n     *\n     * Whenever possible, use {safeIncreaseAllowance} and\n     * {safeDecreaseAllowance} instead.\n     */\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        // safeApprove should only be called when setting an initial allowance,\n        // or when resetting it to zero. To increase and decrease it, use\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n        require(\n            (value == 0) || (token.allowance(address(this), spender) == 0),\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\n        );\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        unchecked {\n            uint256 oldAllowance = token.allowance(address(this), spender);\n            require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\n     * Revert on invalid signature.\n     */\n    function safePermit(\n        IERC20Permit token,\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        uint256 nonceBefore = token.nonces(owner);\n        token.permit(owner, spender, value, deadline, v, r, s);\n        uint256 nonceAfter = token.nonces(owner);\n        require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n        // the target address contains contract code and also asserts for success in the low-level call.\n\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n        // and not revert is the subcall reverts.\n\n        (bool success, bytes memory returndata) = address(token).call(data);\n        return\n            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\n    }\n}\n\n\n// File @openzeppelin/contracts/utils/math/SafeMath.sol@v4.9.6\n\n// Original license: SPDX_License_Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)\n\n\n// CAUTION\n// This version of SafeMath should only be used with Solidity 0.8 or later,\n// because it relies on the compiler's built in overflow checks.\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations.\n *\n * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler\n * now has built in overflow checking.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a + b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a * b;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator.\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a % b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {trySub}.\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        unchecked {\n            require(b <= a, errorMessage);\n            return a - b;\n        }\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        unchecked {\n            require(b > 0, errorMessage);\n            return a / b;\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting with custom message when dividing by zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryMod}.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        unchecked {\n            require(b > 0, errorMessage);\n            return a % b;\n        }\n    }\n}\n\n\n// File contracts/interface/IUniswapV2.sol\n\n// Original license: SPDX_License_Identifier: Unlicense\r\n\r\ninterface IUniswapV2Factory {\r\n    event PairCreated(\r\n        address indexed token0,\r\n        address indexed token1,\r\n        address pair,\r\n        uint256\r\n    );\r\n\r\n    function feeTo() external view returns (address);\r\n\r\n    function feeToSetter() external view returns (address);\r\n\r\n    function getPair(\r\n        address tokenA,\r\n        address tokenB\r\n    ) external view returns (address pair);\r\n\r\n    function allPairs(uint256) external view returns (address pair);\r\n\r\n    function allPairsLength() external view returns (uint256);\r\n\r\n    function createPair(\r\n        address tokenA,\r\n        address tokenB\r\n    ) external returns (address pair);\r\n\r\n    function setFeeTo(address) external;\r\n\r\n    function setFeeToSetter(address) external;\r\n}\r\n\r\ninterface IUniswapV2Pair {\r\n    event Approval(\r\n        address indexed owner,\r\n        address indexed spender,\r\n        uint256 value\r\n    );\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n\r\n    function name() external pure returns (string memory);\r\n\r\n    function symbol() external pure returns (string memory);\r\n\r\n    function decimals() external pure returns (uint8);\r\n\r\n    function totalSupply() external view returns (uint256);\r\n\r\n    function balanceOf(address owner) external view returns (uint256);\r\n\r\n    function allowance(\r\n        address owner,\r\n        address spender\r\n    ) external view returns (uint256);\r\n\r\n    function approve(address spender, uint256 value) external returns (bool);\r\n\r\n    function transfer(address to, uint256 value) external returns (bool);\r\n\r\n    function transferFrom(\r\n        address from,\r\n        address to,\r\n        uint256 value\r\n    ) external returns (bool);\r\n\r\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\r\n\r\n    function PERMIT_TYPEHASH() external pure returns (bytes32);\r\n\r\n    function nonces(address owner) external view returns (uint256);\r\n\r\n    function permit(\r\n        address owner,\r\n        address spender,\r\n        uint256 value,\r\n        uint256 deadline,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external;\r\n\r\n    event Mint(address indexed sender, uint256 amount0, uint256 amount1);\r\n    event Burn(\r\n        address indexed sender,\r\n        uint256 amount0,\r\n        uint256 amount1,\r\n        address indexed to\r\n    );\r\n    event Swap(\r\n        address indexed sender,\r\n        uint256 amount0In,\r\n        uint256 amount1In,\r\n        uint256 amount0Out,\r\n        uint256 amount1Out,\r\n        address indexed to\r\n    );\r\n    event Sync(uint112 reserve0, uint112 reserve1);\r\n\r\n    function MINIMUM_LIQUIDITY() external pure returns (uint256);\r\n\r\n    function factory() external view returns (address);\r\n\r\n    function token0() external view returns (address);\r\n\r\n    function token1() external view returns (address);\r\n\r\n    function getReserves()\r\n        external\r\n        view\r\n        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\r\n\r\n    function price0CumulativeLast() external view returns (uint256);\r\n\r\n    function price1CumulativeLast() external view returns (uint256);\r\n\r\n    function kLast() external view returns (uint256);\r\n\r\n    function mint(address to) external returns (uint256 liquidity);\r\n\r\n    function burn(\r\n        address to\r\n    ) external returns (uint256 amount0, uint256 amount1);\r\n\r\n    function swap(\r\n        uint256 amount0Out,\r\n        uint256 amount1Out,\r\n        address to,\r\n        bytes calldata data\r\n    ) external;\r\n\r\n    function skim(address to) external;\r\n\r\n    function sync() external;\r\n\r\n    function initialize(address, address) external;\r\n}\r\n\r\ninterface IUniswapV2Router01 {\r\n    function factory() external pure returns (address);\r\n\r\n    function WETH() external pure returns (address);\r\n\r\n    function addLiquidity(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 amountADesired,\r\n        uint256 amountBDesired,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);\r\n\r\n    function addLiquidityETH(\r\n        address token,\r\n        uint256 amountTokenDesired,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    )\r\n        external\r\n        payable\r\n        returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);\r\n\r\n    function removeLiquidity(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 liquidity,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountA, uint256 amountB);\r\n\r\n    function removeLiquidityETH(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountToken, uint256 amountETH);\r\n\r\n    function removeLiquidityWithPermit(\r\n        address tokenA,\r\n        address tokenB,\r\n        uint256 liquidity,\r\n        uint256 amountAMin,\r\n        uint256 amountBMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountA, uint256 amountB);\r\n\r\n    function removeLiquidityETHWithPermit(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountToken, uint256 amountETH);\r\n\r\n    function swapExactTokensForTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapTokensForExactTokens(\r\n        uint256 amountOut,\r\n        uint256 amountInMax,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapExactETHForTokens(\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable returns (uint256[] memory amounts);\r\n\r\n    function swapTokensForExactETH(\r\n        uint256 amountOut,\r\n        uint256 amountInMax,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapExactTokensForETH(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256[] memory amounts);\r\n\r\n    function swapETHForExactTokens(\r\n        uint256 amountOut,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable returns (uint256[] memory amounts);\r\n\r\n    function quote(\r\n        uint256 amountA,\r\n        uint256 reserveA,\r\n        uint256 reserveB\r\n    ) external pure returns (uint256 amountB);\r\n\r\n    function getAmountOut(\r\n        uint256 amountIn,\r\n        uint256 reserveIn,\r\n        uint256 reserveOut\r\n    ) external pure returns (uint256 amountOut);\r\n\r\n    function getAmountIn(\r\n        uint256 amountOut,\r\n        uint256 reserveIn,\r\n        uint256 reserveOut\r\n    ) external pure returns (uint256 amountIn);\r\n\r\n    function getAmountsOut(\r\n        uint256 amountIn,\r\n        address[] calldata path\r\n    ) external view returns (uint256[] memory amounts);\r\n\r\n    function getAmountsIn(\r\n        uint256 amountOut,\r\n        address[] calldata path\r\n    ) external view returns (uint256[] memory amounts);\r\n}\r\n\r\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\r\n    function removeLiquidityETHSupportingFeeOnTransferTokens(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline\r\n    ) external returns (uint256 amountETH);\r\n\r\n    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\r\n        address token,\r\n        uint256 liquidity,\r\n        uint256 amountTokenMin,\r\n        uint256 amountETHMin,\r\n        address to,\r\n        uint256 deadline,\r\n        bool approveMax,\r\n        uint8 v,\r\n        bytes32 r,\r\n        bytes32 s\r\n    ) external returns (uint256 amountETH);\r\n\r\n    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external;\r\n\r\n    function swapExactETHForTokensSupportingFeeOnTransferTokens(\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external payable;\r\n\r\n    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r\n        uint256 amountIn,\r\n        uint256 amountOutMin,\r\n        address[] calldata path,\r\n        address to,\r\n        uint256 deadline\r\n    ) external;\r\n}\n\n\n// File contracts/nexus/1_nex.sol\n\n// Original license: SPDX_License_Identifier: MIT\r\ncontract NEX is ERC20, Ownable {\r\n    using SafeMath for uint256;\r\n    using SafeERC20 for IERC20;\r\n\r\n    address public uniswapV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;\r\n    address public uniswapV2PairAid;\r\n\r\n    \r\n    address public tokenAid;\r\n    address public deadWallet = address(0xdead);\r\n    address public devWallet;\r\n\r\n    uint256 public daoFee = 3;\r\n    uint256 public nodeFee = 3;\r\n    address public daoAddress;\r\n    address public nodeAddress;\r\n\r\n    // store addresses that a automatic market maker pairs.\r\n    mapping(address => bool) public automatedMarketMakerPairs;\r\n\r\n    receive() external payable {}\r\n\r\n    constructor(address _router, address _tokenAid) ERC20(\"NEX\", \"NEX\") {\r\n        tokenAid = _tokenAid;\r\n        uniswapV2Router = _router;\r\n\r\n        // Create uniswap pair\r\n        uniswapV2PairAid = IUniswapV2Factory(IUniswapV2Router02(uniswapV2Router).factory()).createPair(address(this), tokenAid);\r\n        \r\n        _setAutomatedMarketMakerPair(address(uniswapV2PairAid), true);\r\n\r\n\r\n        devWallet = _msgSender();\r\n\r\n        uint8 _decimals = 18;\r\n        _mint(owner(), 1_000_000_000 * 10 ** _decimals);\r\n    }\r\n\r\n\r\n    function _setAutomatedMarketMakerPair(address pair, bool value) internal {\r\n        require(automatedMarketMakerPairs[pair] != value, \" : Automated market maker pair is already set to that value\");\r\n        automatedMarketMakerPairs[pair] = value;\r\n    }\r\n\r\n    /** Admin Functions */\r\n    function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {\r\n        require(\r\n            pair != uniswapV2PairAid,\r\n            \"The pair cannot be removed from automatedMarketMakerPairs\"\r\n        );\r\n\r\n        _setAutomatedMarketMakerPair(pair, value);\r\n    }\r\n\r\n    function setFee(uint256 _daoFee, uint256 _nodeFee) external onlyOwner {\r\n        require(_daoFee + _nodeFee <= 50, \" : Fee is too high\");\r\n        daoFee = _daoFee;\r\n        nodeFee = _nodeFee;\r\n    }\r\n\r\n    function setFeeAddress(address _daoAddress, address _nodeAddress) external onlyOwner {\r\n        require(_daoAddress != address(0), \" : Invalid dao address\");\r\n        require(_nodeAddress != address(0), \" : Invalid node address\");\r\n\r\n        daoAddress = _daoAddress;\r\n        nodeAddress = _nodeAddress;\r\n    }\r\n\r\n    function _transfer(\r\n        address from,\r\n        address to,\r\n        uint256 amount\r\n    ) internal override {\r\n        require(from != address(0), \"ERC20: transfer from the zero address\");\r\n        require(to != address(0), \"ERC20: transfer to the zero address\");\r\n\r\n        if(amount == 0) {\r\n            super._transfer(from, to, 0);\r\n            return;\r\n        }\r\n\r\n        bool isSell = automatedMarketMakerPairs[to];\r\n        bool isRouter = (from == uniswapV2Router || to == uniswapV2Router);\r\n\r\n        if (isRouter){\r\n            super._transfer(from, to, amount);\r\n        } else if (isSell){\r\n            uint256 daoTokens = amount.mul(daoFee).div(100);\r\n            uint256 nodeTokens = amount.mul(nodeFee).div(100);\r\n            \r\n            amount = amount.sub(daoTokens).sub(nodeTokens);\r\n\r\n            // to dao\r\n            if (daoTokens > 0){\r\n                super._transfer(from, daoAddress, daoTokens);\r\n            }\r\n\r\n            // to node\r\n            if (nodeTokens > 0){\r\n                super._transfer(from, nodeAddress, nodeTokens);\r\n            }\r\n            \r\n        }\r\n\r\n        super._transfer(from, to, amount);\r\n    }\r\n\r\n    function claimStuckTokens(address _token) external {\r\n        Address.sendValue(payable(devWallet), address(this).balance);\r\n        if (_token != address(0) && _token != address(this)) {\r\n            IERC20(_token).safeTransfer(devWallet, IERC20(_token).balanceOf(address(this)));\r\n        }\r\n    }\r\n\r\n    /** View Functions */\r\n}\n"}},"language":"Solidity","settings":{"optimizer":{"runs":200,"enabled":true}}},"stdJsonOutput":{"sources":{"contracts/flatten/nexus_nex.sol":{"id":0}},"contracts":{"contracts/flatten/nexus_nex.sol":{"NEX":{"abi":[{"type":"constructor","inputs":[{"name":"_router","type":"address","internalType":"address"},{"name":"_tokenAid","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"automatedMarketMakerPairs","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claimStuckTokens","type":"function","inputs":[{"name":"_token","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"daoAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"daoFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"deadWallet","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"devWallet","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"nodeAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"nodeFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setAutomatedMarketMakerPair","type":"function","inputs":[{"name":"pair","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setFee","type":"function","inputs":[{"name":"_daoFee","type":"uint256","internalType":"uint256"},{"name":"_nodeFee","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setFeeAddress","type":"function","inputs":[{"name":"_daoAddress","type":"address","internalType":"address"},{"name":"_nodeAddress","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"tokenAid","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"uniswapV2PairAid","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"uniswapV2Router","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.18+commit.87f61d96\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_router\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_tokenAid\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"automatedMarketMakerPairs\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"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\":\"_token\",\"type\":\"address\"}],\"name\":\"claimStuckTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"daoAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"daoFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deadWallet\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"devWallet\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nodeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nodeFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"setAutomatedMarketMakerPair\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_daoFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_nodeFee\",\"type\":\"uint256\"}],\"name\":\"setFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_daoAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_nodeAddress\",\"type\":\"address\"}],\"name\":\"setFeeAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenAid\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapV2PairAid\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapV2Router\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"decreaseAllowance(address,uint256)\":{\"details\":\"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.\"},\"increaseAllowance(address,uint256)\":{\"details\":\"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.\"},\"name()\":{\"details\":\"Returns the name of the token.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"setAutomatedMarketMakerPair(address,bool)\":{\"notice\":\"Admin Functions \"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/flatten/nexus_nex.sol\":\"NEX\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/flatten/nexus_nex.sol\":{\"keccak256\":\"0xc3d1394fb997f9ac9954c7cb1c1bc32a5147005c685f779a73fdd738629a3d07\",\"license\":\"MIT AND Unlicense\",\"urls\":[\"bzz-raw://bd3e9fb250ede66d558dcfb66aa126d74cb0c7ebc607d7514d4236c4afd75795\",\"dweb:/ipfs/QmbVr6y5gsvZsNTrWKDDfAmSmUQ4SwSU693D2Lok8Zvp27\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{"setAutomatedMarketMakerPair(address,bool)":{"notice":"Admin Functions "}},"version":1},"devdoc":{"kind":"dev","events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":248,"label":"_balances","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":254,"label":"_allowances","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"2","type":"t_uint256","astId":256,"label":"_totalSupply","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"3","type":"t_string_storage","astId":258,"label":"_name","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"4","type":"t_string_storage","astId":260,"label":"_symbol","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"5","type":"t_address","astId":34,"label":"_owner","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"6","type":"t_address","astId":2568,"label":"uniswapV2Router","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"7","type":"t_address","astId":2570,"label":"uniswapV2PairAid","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"8","type":"t_address","astId":2572,"label":"tokenAid","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"9","type":"t_address","astId":2578,"label":"deadWallet","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"10","type":"t_address","astId":2580,"label":"devWallet","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"11","type":"t_uint256","astId":2583,"label":"daoFee","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"12","type":"t_uint256","astId":2586,"label":"nodeFee","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"13","type":"t_address","astId":2588,"label":"daoAddress","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"14","type":"t_address","astId":2590,"label":"nodeAddress","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"},{"slot":"15","type":"t_mapping(t_address,t_bool)","astId":2594,"label":"automatedMarketMakerPairs","offset":0,"contract":"contracts/flatten/nexus_nex.sol:NEX"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"56438:3783:0:-:0;;;56544:75;;;-1:-1:-1;;;;;;56544:75:0;;;56577:42;56544:75;;;;56702:43;;;;;;56738:6;56702:43;;;56809:1;56785:25;;;;56817:26;;57081:519;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9259:113;;;;;;;;;;;;-1:-1:-1;;;9259:113:0;;;;;;;;;;;;;;;;;;;;;;;;9325:13;9259:113;;9325:13;:::i;:::-;-1:-1:-1;9348:7:0;:17;9358:7;9348;:17;:::i;:::-;;9259:113;;2107:32;2126:12;:10;;;:12;;:::i;:::-;2107:18;:32::i;:::-;57160:8:::1;:20:::0;;-1:-1:-1;;;;;57160:20:0;;::::1;-1:-1:-1::0;;;;;;57160:20:0;;::::1;;::::0;;;57191:15:::1;:25:::0;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;57298:45:::1;::::0;;-1:-1:-1;;;57298:45:0;;;;:43:::1;::::0;:45:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;57191:25;57298:45:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57371:8;::::0;57280:100:::1;::::0;-1:-1:-1;;;57280:100:0;;57364:4:::1;57280:100;::::0;::::1;3640:34:1::0;-1:-1:-1;;;;;57371:8:0;;::::1;3690:18:1::0;;;3683:43;57280:75:0;::::1;::::0;::::1;::::0;3575:18:1;;57280:100:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57261:16;:119:::0;;-1:-1:-1;;;;;;57261:119:0::1;-1:-1:-1::0;;;;;57261:119:0;;;::::1;::::0;;::::1;::::0;;57401:61:::1;::::0;-1:-1:-1;57401:28:0::1;:61::i;:::-;57477:9;:24:::0;;-1:-1:-1;;;;;;57477:24:0::1;920:10:::0;57477:24:::1;::::0;;2444:6;;57532:2:::1;::::0;57545:47:::1;::::0;-1:-1:-1;;;;;2444:6:0;;57576:15:::1;::::0;57532:2;;57576:15:::1;:::i;:::-;57560:31;::::0;:13:::1;:31;:::i;:::-;57545:5;:47::i;:::-;57149:451;57081:519:::0;;56438:3783;;841:96;920:10;;841:96::o;3597:187::-;3689:6;;;-1:-1:-1;;;;;3705:17:0;;;-1:-1:-1;;;;;;3705:17:0;;;;;;;3737:40;;3689:6;;;3705:17;3689:6;;3737:40;;3670:16;;3737:40;3660:124;3597:187;:::o;57610:254::-;-1:-1:-1;;;;;57702:31:0;;;;;;:25;:31;;;;;;:40;;;:31;;;;:40;;;57694:112;;;;-1:-1:-1;;;57694:112:0;;5627:2:1;57694:112:0;;;5609:21:1;5666:2;5646:18;;;5639:30;5705:34;5685:18;;;5678:62;5776:29;5756:18;;;5749:57;5823:19;;57694:112:0;;;;;;;;;-1:-1:-1;;;;;57817:31:0;;;;;;;;:25;:31;;;;;:39;;-1:-1:-1;;57817:39:0;;;;;;;;;;57610:254::o;15799:535::-;-1:-1:-1;;;;;15882:21:0;;15874:65;;;;-1:-1:-1;;;15874:65:0;;6055:2:1;15874:65:0;;;6037:21:1;6094:2;6074:18;;;6067:30;6133:33;6113:18;;;6106:61;6184:18;;15874:65:0;5853:355:1;15874:65:0;16026:6;16010:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;16178:18:0;;:9;:18;;;;;;;;;;;:28;;;;;;16231:37;6489:25:1;;;16231:37:0;;6462:18:1;16231:37:0;;;;;;;15799:535;;:::o;19352:91::-;;;;:::o;14:177:1:-;93:13;;-1:-1:-1;;;;;135:31:1;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;494:127::-;555:10;550:3;546:20;543:1;536:31;586:4;583:1;576:15;610:4;607:1;600:15;626:380;705:1;701:12;;;;748;;;769:61;;823:4;815:6;811:17;801:27;;769:61;876:2;868:6;865:14;845:18;842:38;839:161;;922:10;917:3;913:20;910:1;903:31;957:4;954:1;947:15;985:4;982:1;975:15;839:161;;626:380;;;:::o;1137:545::-;1239:2;1234:3;1231:11;1228:448;;;1275:1;1300:5;1296:2;1289:17;1345:4;1341:2;1331:19;1415:2;1403:10;1399:19;1396:1;1392:27;1386:4;1382:38;1451:4;1439:10;1436:20;1433:47;;;-1:-1:-1;1474:4:1;1433:47;1529:2;1524:3;1520:12;1517:1;1513:20;1507:4;1503:31;1493:41;;1584:82;1602:2;1595:5;1592:13;1584:82;;;1647:17;;;1628:1;1617:13;1584:82;;;1588:3;;;1137:545;;;:::o;1858:1352::-;1978:10;;-1:-1:-1;;;;;2000:30:1;;1997:56;;;2033:18;;:::i;:::-;2062:97;2152:6;2112:38;2144:4;2138:11;2112:38;:::i;:::-;2106:4;2062:97;:::i;:::-;2214:4;;2278:2;2267:14;;2295:1;2290:663;;;;2997:1;3014:6;3011:89;;;-1:-1:-1;3066:19:1;;;3060:26;3011:89;-1:-1:-1;;1815:1:1;1811:11;;;1807:24;1803:29;1793:40;1839:1;1835:11;;;1790:57;3113:81;;2260:944;;2290:663;1084:1;1077:14;;;1121:4;1108:18;;-1:-1:-1;;2326:20:1;;;2444:236;2458:7;2455:1;2452:14;2444:236;;;2547:19;;;2541:26;2526:42;;2639:27;;;;2607:1;2595:14;;;;2474:19;;2444:236;;;2448:3;2708:6;2699:7;2696:19;2693:201;;;2769:19;;;2763:26;-1:-1:-1;;2852:1:1;2848:14;;;2864:3;2844:24;2840:37;2836:42;2821:58;2806:74;;2693:201;-1:-1:-1;;;;;2940:1:1;2924:14;;;2920:22;2907:36;;-1:-1:-1;1858:1352:1:o;3215:208::-;3285:6;3338:2;3326:9;3317:7;3313:23;3309:32;3306:52;;;3354:1;3351;3344:12;3306:52;3377:40;3407:9;3377:40;:::i;:::-;3367:50;3215:208;-1:-1:-1;;;3215:208:1:o;3737:127::-;3798:10;3793:3;3789:20;3786:1;3779:31;3829:4;3826:1;3819:15;3853:4;3850:1;3843:15;3869:422;3958:1;4001:5;3958:1;4015:270;4036:7;4026:8;4023:21;4015:270;;;4095:4;4091:1;4087:6;4083:17;4077:4;4074:27;4071:53;;;4104:18;;:::i;:::-;4154:7;4144:8;4140:22;4137:55;;;4174:16;;;;4137:55;4253:22;;;;4213:15;;;;4015:270;;;4019:3;3869:422;;;;;:::o;4296:806::-;4345:5;4375:8;4365:80;;-1:-1:-1;4416:1:1;4430:5;;4365:80;4464:4;4454:76;;-1:-1:-1;4501:1:1;4515:5;;4454:76;4546:4;4564:1;4559:59;;;;4632:1;4627:130;;;;4539:218;;4559:59;4589:1;4580:10;;4603:5;;;4627:130;4664:3;4654:8;4651:17;4648:43;;;4671:18;;:::i;:::-;-1:-1:-1;;4727:1:1;4713:16;;4742:5;;4539:218;;4841:2;4831:8;4828:16;4822:3;4816:4;4813:13;4809:36;4803:2;4793:8;4790:16;4785:2;4779:4;4776:12;4772:35;4769:77;4766:159;;;-1:-1:-1;4878:19:1;;;4910:5;;4766:159;4957:34;4982:8;4976:4;4957:34;:::i;:::-;5027:6;5023:1;5019:6;5015:19;5006:7;5003:32;5000:58;;;5038:18;;:::i;:::-;5076:20;;-1:-1:-1;4296:806:1;;;;;:::o;5107:140::-;5165:5;5194:47;5235:4;5225:8;5221:19;5215:4;5194:47;:::i;5252:168::-;5325:9;;;5356;;5373:15;;;5367:22;;5353:37;5343:71;;5394:18;;:::i;6213:125::-;6278:9;;;6299:10;;;6296:36;;;6312:18;;:::i;6343:177::-;56438:3783:0;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"56438:3783:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9437:98;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11723:197;;;;;;;;;;-1:-1:-1;11723:197:0;;;;;:::i;:::-;;:::i;:::-;;;1272:14:1;;1265:22;1247:41;;1235:2;1220:18;11723:197:0;1107:187:1;56544:75:0;;;;;;;;;;-1:-1:-1;56544:75:0;;;;-1:-1:-1;;;;;56544:75:0;;;;;;-1:-1:-1;;;;;1463:32:1;;;1445:51;;1433:2;1418:18;56544:75:0;1299:203:1;10534:106:0;;;;;;;;;;-1:-1:-1;10621:12:0;;10534:106;;;1653:25:1;;;1641:2;1626:18;10534:106:0;1507:177:1;56850:25:0;;;;;;;;;;-1:-1:-1;56850:25:0;;;;-1:-1:-1;;;;;56850:25:0;;;12482:256;;;;;;;;;;-1:-1:-1;12482:256:0;;;;;:::i;:::-;;:::i;56785:25::-;;;;;;;;;;;;;;;;56882:26;;;;;;;;;;-1:-1:-1;56882:26:0;;;;-1:-1:-1;;;;;56882:26:0;;;10383:91;;;;;;;;;;-1:-1:-1;10383:91:0;;10465:2;2164:36:1;;2152:2;2137:18;10383:91:0;2022:184:1;13133:234:0;;;;;;;;;;-1:-1:-1;13133:234:0;;;;;:::i;:::-;;:::i;58192:200::-;;;;;;;;;;-1:-1:-1;58192:200:0;;;;;:::i;:::-;;:::i;:::-;;58400:311;;;;;;;;;;-1:-1:-1;58400:311:0;;;;;:::i;:::-;;:::i;10698:125::-;;;;;;;;;;-1:-1:-1;10698:125:0;;;;;:::i;:::-;-1:-1:-1;;;;;10798:18:0;10772:7;10798:18;;;;;;;;;;;;10698:125;2995:101;;;;;;;;;;;;;:::i;56672:23::-;;;;;;;;;;-1:-1:-1;56672:23:0;;;;-1:-1:-1;;;;;56672:23:0;;;56702:43;;;;;;;;;;-1:-1:-1;56702:43:0;;;;-1:-1:-1;;;;;56702:43:0;;;2372:85;;;;;;;;;;-1:-1:-1;2444:6:0;;-1:-1:-1;;;;;2444:6:0;2372:85;;56752:24;;;;;;;;;;-1:-1:-1;56752:24:0;;;;-1:-1:-1;;;;;56752:24:0;;;56626:31;;;;;;;;;;-1:-1:-1;56626:31:0;;;;-1:-1:-1;;;;;56626:31:0;;;9648:102;;;;;;;;;;;;;:::i;57900:284::-;;;;;;;;;;-1:-1:-1;57900:284:0;;;;;:::i;:::-;;:::i;13854:427::-;;;;;;;;;;-1:-1:-1;13854:427:0;;;;;:::i;:::-;;:::i;11019:189::-;;;;;;;;;;-1:-1:-1;11019:189:0;;;;;:::i;:::-;;:::i;56978:57::-;;;;;;;;;;-1:-1:-1;56978:57:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;11266:149;;;;;;;;;;-1:-1:-1;11266:149:0;;;;;:::i;:::-;;:::i;3245:198::-;;;;;;;;;;-1:-1:-1;3245:198:0;;;;;:::i;:::-;;:::i;56817:26::-;;;;;;;;;;;;;;;;59890:299;;;;;;;;;;-1:-1:-1;59890:299:0;;;;;:::i;:::-;;:::i;9437:98::-;9491:13;9523:5;9516:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9437:98;:::o;11723:197::-;11806:4;920:10;11860:32;920:10;11876:7;11885:6;11860:8;:32::i;:::-;11909:4;11902:11;;;11723:197;;;;;:::o;12482:256::-;12579:4;920:10;12635:38;12651:4;920:10;12666:6;12635:15;:38::i;:::-;12683:27;12693:4;12699:2;12703:6;12683:9;:27::i;:::-;-1:-1:-1;12727:4:0;;12482:256;-1:-1:-1;;;;12482:256:0:o;13133:234::-;13221:4;920:10;13275:64;920:10;13291:7;13328:10;13300:25;920:10;13291:7;13300:9;:25::i;:::-;:38;;;;:::i;:::-;13275:8;:64::i;58192:200::-;2265:13;:11;:13::i;:::-;58303:2:::1;58281:18;58291:8:::0;58281:7;:18:::1;:::i;:::-;:24;;58273:55;;;::::0;-1:-1:-1;;;58273:55:0;;4212:2:1;58273:55:0::1;::::0;::::1;4194:21:1::0;4251:2;4231:18;;;4224:30;-1:-1:-1;;;4270:18:1;;;4263:48;4328:18;;58273:55:0::1;;;;;;;;;58339:6;:16:::0;;;;58366:7:::1;:18:::0;58192:200::o;58400:311::-;2265:13;:11;:13::i;:::-;-1:-1:-1;;;;;58504:25:0;::::1;58496:60;;;::::0;-1:-1:-1;;;58496:60:0;;4559:2:1;58496:60:0::1;::::0;::::1;4541:21:1::0;4598:2;4578:18;;;4571:30;-1:-1:-1;;;4617:18:1;;;4610:52;4679:18;;58496:60:0::1;4357:346:1::0;58496:60:0::1;-1:-1:-1::0;;;;;58575:26:0;::::1;58567:62;;;::::0;-1:-1:-1;;;58567:62:0;;4910:2:1;58567:62:0::1;::::0;::::1;4892:21:1::0;4949:2;4929:18;;;4922:30;4988:25;4968:18;;;4961:53;5031:18;;58567:62:0::1;4708:347:1::0;58567:62:0::1;58642:10;:24:::0;;-1:-1:-1;;;;;58642:24:0;;::::1;-1:-1:-1::0;;;;;;58642:24:0;;::::1;;::::0;;;58677:11:::1;:26:::0;;;;;::::1;::::0;::::1;;::::0;;58400:311::o;2995:101::-;2265:13;:11;:13::i;:::-;3059:30:::1;3086:1;3059:18;:30::i;:::-;2995:101::o:0;9648:102::-;9704:13;9736:7;9729:14;;;;;:::i;57900:284::-;2265:13;:11;:13::i;:::-;58021:16:::1;::::0;-1:-1:-1;;;;;58021:16:0;;::::1;58013:24:::0;;::::1;::::0;57991:131:::1;;;::::0;-1:-1:-1;;;57991:131:0;;5262:2:1;57991:131:0::1;::::0;::::1;5244:21:1::0;5301:2;5281:18;;;5274:30;5340:34;5320:18;;;5313:62;5411:27;5391:18;;;5384:55;5456:19;;57991:131:0::1;5060:421:1::0;57991:131:0::1;58135:41;58164:4;58170:5;58135:28;:41::i;:::-;57900:284:::0;;:::o;13854:427::-;13947:4;920:10;13947:4;14028:25;920:10;14045:7;14028:9;:25::i;:::-;14001:52;;14091:15;14071:16;:35;;14063:85;;;;-1:-1:-1;;;14063:85:0;;5688:2:1;14063:85:0;;;5670:21:1;5727:2;5707:18;;;5700:30;5766:34;5746:18;;;5739:62;-1:-1:-1;;;5817:18:1;;;5810:35;5862:19;;14063:85:0;5486:401:1;14063:85:0;14182:60;14191:5;14198:7;14226:15;14207:16;:34;14182:8;:60::i;11019:189::-;11098:4;920:10;11152:28;920:10;11169:2;11173:6;11152:9;:28::i;11266:149::-;-1:-1:-1;;;;;11381:18:0;;;11355:7;11381:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;11266:149::o;3245:198::-;2265:13;:11;:13::i;:::-;-1:-1:-1;;;;;3333:22:0;::::1;3325:73;;;::::0;-1:-1:-1;;;3325:73:0;;6094:2:1;3325:73:0::1;::::0;::::1;6076:21:1::0;6133:2;6113:18;;;6106:30;6172:34;6152:18;;;6145:62;-1:-1:-1;;;6223:18:1;;;6216:36;6269:19;;3325:73:0::1;5892:402:1::0;3325:73:0::1;3408:28;3427:8;3408:18;:28::i;:::-;3245:198:::0;:::o;59890:299::-;59978:9;;59952:60;;-1:-1:-1;;;;;59978:9:0;59990:21;59952:17;:60::i;:::-;-1:-1:-1;;;;;60027:20:0;;;;;;:47;;-1:-1:-1;;;;;;60051:23:0;;60069:4;60051:23;;60027:47;60023:159;;;60119:9;;60130:39;;-1:-1:-1;;;60130:39:0;;60163:4;60130:39;;;1445:51:1;60091:79:0;;-1:-1:-1;;;;;60119:9:0;;;;60130:24;;;;;;1418:18:1;;60130:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;60091:27:0;;;:79;:27;:79::i;17736:340::-;-1:-1:-1;;;;;17837:19:0;;17829:68;;;;-1:-1:-1;;;17829:68:0;;6690:2:1;17829:68:0;;;6672:21:1;6729:2;6709:18;;;6702:30;6768:34;6748:18;;;6741:62;-1:-1:-1;;;6819:18:1;;;6812:34;6863:19;;17829:68:0;6488:400:1;17829:68:0;-1:-1:-1;;;;;17915:21:0;;17907:68;;;;-1:-1:-1;;;17907:68:0;;7095:2:1;17907:68:0;;;7077:21:1;7134:2;7114:18;;;7107:30;7173:34;7153:18;;;7146:62;-1:-1:-1;;;7224:18:1;;;7217:32;7266:19;;17907:68:0;6893:398:1;17907:68:0;-1:-1:-1;;;;;17986:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;18037:32;;1653:25:1;;;18037:32:0;;1626:18:1;18037:32:0;;;;;;;17736:340;;;:::o;18357:411::-;18457:24;18484:25;18494:5;18501:7;18484:9;:25::i;:::-;18457:52;;-1:-1:-1;;18523:16:0;:37;18519:243;;18604:6;18584:16;:26;;18576:68;;;;-1:-1:-1;;;18576:68:0;;7498:2:1;18576:68:0;;;7480:21:1;7537:2;7517:18;;;7510:30;7576:31;7556:18;;;7549:59;7625:18;;18576:68:0;7296:353:1;18576:68:0;18686:51;18695:5;18702:7;18730:6;18711:16;:25;18686:8;:51::i;:::-;18447:321;18357:411;;;:::o;58719:1163::-;-1:-1:-1;;;;;58851:18:0;;58843:68;;;;-1:-1:-1;;;58843:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;58930:16:0;;58922:64;;;;-1:-1:-1;;;58922:64:0;;;;;;;:::i;:::-;59002:6;59012:1;59002:11;58999:92;;59030:28;59046:4;59052:2;59056:1;59030:15;:28::i;:::-;58719:1163;;;:::o;58999:92::-;-1:-1:-1;;;;;59117:29:0;;;59103:11;59117:29;;;:25;:29;;;;;;59182:15;;59117:29;;;;;59174:23;;;59182:15;;59174:23;;:48;;-1:-1:-1;59207:15:0;;-1:-1:-1;;;;;59201:21:0;;;59207:15;;59201:21;59174:48;59157:66;;59240:8;59236:593;;;59264:33;59280:4;59286:2;59290:6;59264:15;:33::i;:::-;59236:593;;;59319:6;59315:514;;;59341:17;59361:27;59384:3;59361:18;59372:6;;59361;:10;;:18;;;;:::i;:::-;:22;;:27::i;:::-;59341:47;;59403:18;59424:28;59448:3;59424:19;59435:7;;59424:6;:10;;:19;;;;:::i;:28::-;59403:49;-1:-1:-1;59490:37:0;59403:49;59490:21;:6;59501:9;59490:10;:21::i;:::-;:25;;:37::i;:::-;59481:46;-1:-1:-1;59571:13:0;;59567:97;;59626:10;;59604:44;;59620:4;;-1:-1:-1;;;;;59626:10:0;59638:9;59604:15;:44::i;:::-;59708:14;;59704:100;;59764:11;;59742:46;;59758:4;;-1:-1:-1;;;;;59764:11:0;59777:10;59742:15;:46::i;:::-;59326:503;;59315:514;59841:33;59857:4;59863:2;59867:6;59841:15;:33::i;:::-;58832:1050;;58719:1163;;;:::o;2530:130::-;2444:6;;-1:-1:-1;;;;;2444:6:0;920:10;2593:23;2585:68;;;;-1:-1:-1;;;2585:68:0;;8666:2:1;2585:68:0;;;8648:21:1;;;8685:18;;;8678:30;8744:34;8724:18;;;8717:62;8796:18;;2585:68:0;8464:356:1;3597:187:0;3689:6;;;-1:-1:-1;;;;;3705:17:0;;;-1:-1:-1;;;;;;3705:17:0;;;;;;;3737:40;;3689:6;;;3705:17;3689:6;;3737:40;;3670:16;;3737:40;3660:124;3597:187;:::o;57610:254::-;-1:-1:-1;;;;;57702:31:0;;;;;;:25;:31;;;;;;:40;;;:31;;;;:40;;;57694:112;;;;-1:-1:-1;;;57694:112:0;;9027:2:1;57694:112:0;;;9009:21:1;9066:2;9046:18;;;9039:30;9105:34;9085:18;;;9078:62;9176:29;9156:18;;;9149:57;9223:19;;57694:112:0;8825:423:1;57694:112:0;-1:-1:-1;;;;;57817:31:0;;;;;;;;:25;:31;;;;;:39;;-1:-1:-1;;57817:39:0;;;;;;;;;;57610:254::o;26703:312::-;26817:6;26792:21;:31;;26784:73;;;;-1:-1:-1;;;26784:73:0;;9455:2:1;26784:73:0;;;9437:21:1;9494:2;9474:18;;;9467:30;9533:31;9513:18;;;9506:59;9582:18;;26784:73:0;9253:353:1;26784:73:0;26869:12;26887:9;-1:-1:-1;;;;;26887:14:0;26909:6;26887:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26868:52;;;26938:7;26930:78;;;;-1:-1:-1;;;26930:78:0;;10023:2:1;26930:78:0;;;10005:21:1;10062:2;10042:18;;;10035:30;10101:34;10081:18;;;10074:62;10172:28;10152:18;;;10145:56;10218:19;;26930:78:0;9821:422:1;34328:175:0;34437:58;;;-1:-1:-1;;;;;10440:32:1;;34437:58:0;;;10422:51:1;10489:18;;;;10482:34;;;34437:58:0;;;;;;;;;;10395:18:1;;;;34437:58:0;;;;;;;;-1:-1:-1;;;;;34437:58:0;-1:-1:-1;;;34437:58:0;;;34410:86;;34430:5;;34410:19;:86::i;14735:788::-;-1:-1:-1;;;;;14831:18:0;;14823:68;;;;-1:-1:-1;;;14823:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;14909:16:0;;14901:64;;;;-1:-1:-1;;;14901:64:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;15047:15:0;;15025:19;15047:15;;;;;;;;;;;15080:21;;;;15072:72;;;;-1:-1:-1;;;15072:72:0;;10729:2:1;15072:72:0;;;10711:21:1;10768:2;10748:18;;;10741:30;10807:34;10787:18;;;10780:62;-1:-1:-1;;;10858:18:1;;;10851:36;10904:19;;15072:72:0;10527:402:1;15072:72:0;-1:-1:-1;;;;;15178:15:0;;;:9;:15;;;;;;;;;;;15196:20;;;15178:38;;15393:13;;;;;;;;;;:23;;;;;;15442:26;;1653:25:1;;;15393:13:0;;15442:26;;1626:18:1;15442:26:0;;;;;;;15479:37;58719:1163;43848:96;43906:7;43932:5;43936:1;43932;:5;:::i;:::-;43925:12;43848:96;-1:-1:-1;;;43848:96:0:o;44233:::-;44291:7;44317:5;44321:1;44317;:5;:::i;43505:96::-;43563:7;43589:5;43593:1;43589;:5;:::i;38583:642::-;39002:23;39028:69;39056:4;39028:69;;;;;;;;;;;;;;;;;39036:5;-1:-1:-1;;;;;39028:27:0;;;:69;;;;;:::i;:::-;39002:95;;39115:10;:17;39136:1;39115:22;:56;;;;39152:10;39141:30;;;;;;;;;;;;:::i;:::-;39107:111;;;;-1:-1:-1;;;39107:111:0;;11914:2:1;39107:111:0;;;11896:21:1;11953:2;11933:18;;;11926:30;11992:34;11972:18;;;11965:62;-1:-1:-1;;;12043:18:1;;;12036:40;12093:19;;39107:111:0;11712:406:1;28164:223:0;28297:12;28328:52;28350:6;28358:4;28364:1;28367:12;28328:21;:52::i;:::-;28321:59;28164:223;-1:-1:-1;;;;28164:223:0:o;29221:446::-;29386:12;29443:5;29418:21;:30;;29410:81;;;;-1:-1:-1;;;29410:81:0;;12325:2:1;29410:81:0;;;12307:21:1;12364:2;12344:18;;;12337:30;12403:34;12383:18;;;12376:62;-1:-1:-1;;;12454:18:1;;;12447:36;12500:19;;29410:81:0;12123:402:1;29410:81:0;29502:12;29516:23;29543:6;-1:-1:-1;;;;;29543:11:0;29562:5;29569:4;29543:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29501:73;;;;29591:69;29618:6;29626:7;29635:10;29647:12;29591:26;:69::i;:::-;29584:76;29221:446;-1:-1:-1;;;;;;;29221:446:0:o;31727:628::-;31907:12;31935:7;31931:418;;;31962:10;:17;31983:1;31962:22;31958:286;;-1:-1:-1;;;;;25758:19:0;;;32169:60;;;;-1:-1:-1;;;32169:60:0;;13024:2:1;32169:60:0;;;13006:21:1;13063:2;13043:18;;;13036:30;13102:31;13082:18;;;13075:59;13151:18;;32169:60:0;12822:353:1;32169:60:0;-1:-1:-1;32264:10:0;32257:17;;31931:418;32305:33;32313:10;32325:12;33036:17;;:21;33032:379;;33264:10;33258:17;33320:15;33307:10;33303:2;33299:19;33292:44;33032:379;33387:12;33380:20;;-1:-1:-1;;;33380:20:0;;;;;;;;:::i;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:396::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;649:2;628:15;-1:-1:-1;;624:29:1;609:45;;;;656:2;605:54;;269:396;-1:-1:-1;;269:396:1:o;670:173::-;738:20;;-1:-1:-1;;;;;787:31:1;;777:42;;767:70;;833:1;830;823:12;767:70;670:173;;;:::o;848:254::-;916:6;924;977:2;965:9;956:7;952:23;948:32;945:52;;;993:1;990;983:12;945:52;1016:29;1035:9;1016:29;:::i;:::-;1006:39;1092:2;1077:18;;;;1064:32;;-1:-1:-1;;;848:254:1:o;1689:328::-;1766:6;1774;1782;1835:2;1823:9;1814:7;1810:23;1806:32;1803:52;;;1851:1;1848;1841:12;1803:52;1874:29;1893:9;1874:29;:::i;:::-;1864:39;;1922:38;1956:2;1945:9;1941:18;1922:38;:::i;:::-;1912:48;;2007:2;1996:9;1992:18;1979:32;1969:42;;1689:328;;;;;:::o;2211:248::-;2279:6;2287;2340:2;2328:9;2319:7;2315:23;2311:32;2308:52;;;2356:1;2353;2346:12;2308:52;-1:-1:-1;;2379:23:1;;;2449:2;2434:18;;;2421:32;;-1:-1:-1;2211:248:1:o;2464:260::-;2532:6;2540;2593:2;2581:9;2572:7;2568:23;2564:32;2561:52;;;2609:1;2606;2599:12;2561:52;2632:29;2651:9;2632:29;:::i;:::-;2622:39;;2680:38;2714:2;2703:9;2699:18;2680:38;:::i;:::-;2670:48;;2464:260;;;;;:::o;2729:186::-;2788:6;2841:2;2829:9;2820:7;2816:23;2812:32;2809:52;;;2857:1;2854;2847:12;2809:52;2880:29;2899:9;2880:29;:::i;2920:118::-;3006:5;2999:13;2992:21;2985:5;2982:32;2972:60;;3028:1;3025;3018:12;3043:315;3108:6;3116;3169:2;3157:9;3148:7;3144:23;3140:32;3137:52;;;3185:1;3182;3175:12;3137:52;3208:29;3227:9;3208:29;:::i;:::-;3198:39;;3287:2;3276:9;3272:18;3259:32;3300:28;3322:5;3300:28;:::i;:::-;3347:5;3337:15;;;3043:315;;;;;:::o;3363:380::-;3442:1;3438:12;;;;3485;;;3506:61;;3560:4;3552:6;3548:17;3538:27;;3506:61;3613:2;3605:6;3602:14;3582:18;3579:38;3576:161;;3659:10;3654:3;3650:20;3647:1;3640:31;3694:4;3691:1;3684:15;3722:4;3719:1;3712:15;3576:161;;3363:380;;;:::o;3748:127::-;3809:10;3804:3;3800:20;3797:1;3790:31;3840:4;3837:1;3830:15;3864:4;3861:1;3854:15;3880:125;3945:9;;;3966:10;;;3963:36;;;3979:18;;:::i;6299:184::-;6369:6;6422:2;6410:9;6401:7;6397:23;6393:32;6390:52;;;6438:1;6435;6428:12;6390:52;-1:-1:-1;6461:16:1;;6299:184;-1:-1:-1;6299:184:1:o;7654:401::-;7856:2;7838:21;;;7895:2;7875:18;;;7868:30;7934:34;7929:2;7914:18;;7907:62;-1:-1:-1;;;8000:2:1;7985:18;;7978:35;8045:3;8030:19;;7654:401::o;8060:399::-;8262:2;8244:21;;;8301:2;8281:18;;;8274:30;8340:34;8335:2;8320:18;;8313:62;-1:-1:-1;;;8406:2:1;8391:18;;8384:33;8449:3;8434:19;;8060:399::o;10934:168::-;11007:9;;;11038;;11055:15;;;11049:22;;11035:37;11025:71;;11076:18;;:::i;11107:217::-;11147:1;11173;11163:132;;11217:10;11212:3;11208:20;11205:1;11198:31;11252:4;11249:1;11242:15;11280:4;11277:1;11270:15;11163:132;-1:-1:-1;11309:9:1;;11107:217::o;11329:128::-;11396:9;;;11417:11;;;11414:37;;;11431:18;;:::i;11462:245::-;11529:6;11582:2;11570:9;11561:7;11557:23;11553:32;11550:52;;;11598:1;11595;11588:12;11550:52;11630:9;11624:16;11649:28;11671:5;11649:28;:::i;12530:287::-;12659:3;12697:6;12691:13;12713:66;12772:6;12767:3;12760:4;12752:6;12748:17;12713:66;:::i;:::-;12795:16;;;;;12530:287;-1:-1:-1;;12530:287:1:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"automatedMarketMakerPairs(address)","signatureHash4":"0xb62496f5","signatureHash32":"0xb62496f5586b0c70b3946286dabd06d9c4aaac9c7d149f02c247134232574805"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"claimStuckTokens(address)","signatureHash4":"0xf9d0831a","signatureHash32":"0xf9d0831a71895cdfc0fec981d39127e7ab103a991c0bd327d9003b710ec44a5a"},{"signature":"daoAddress()","signatureHash4":"0x2131c68c","signatureHash32":"0x2131c68ca7208993695e1fa86c2c8272a8de9bb49b28302cd64bfb2d1a69e42c"},{"signature":"daoFee()","signatureHash4":"0x2957b839","signatureHash32":"0x2957b8391f82ef4cc3840eb67f31397c5e877d9d73424f8afa13629e84dd6240"},{"signature":"deadWallet()","signatureHash4":"0x85141a77","signatureHash32":"0x85141a770f035f04ba989efe3e2509cd38593945a4cae73a9a16d96f7526b2c0"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"decreaseAllowance(address,uint256)","signatureHash4":"0xa457c2d7","signatureHash32":"0xa457c2d77307f80ff2f3ac810ec99eb18ae2cffee13b29c90c9324546e374be5"},{"signature":"devWallet()","signatureHash4":"0x8ea5220f","signatureHash32":"0x8ea5220f777d6f00e922a0e62f88cd8badb6944e5d64af96ccd77b1f02b17af0"},{"signature":"increaseAllowance(address,uint256)","signatureHash4":"0x39509351","signatureHash32":"0x39509351d3325647dde3fdd3c8b249adfe89ef4f16d76d83768e6df7a5cd81d6"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"nodeAddress()","signatureHash4":"0x2aa8481f","signatureHash32":"0x2aa8481ff0d210a38aec0592c02b797d7dc5790fd7f5938f60d198cd634ea1d5"},{"signature":"nodeFee()","signatureHash4":"0xf4162530","signatureHash32":"0xf416253091440af1e5cc645f2ebfbd108e655799ef31ef88076cfd77b1e72121"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"setAutomatedMarketMakerPair(address,bool)","signatureHash4":"0x9a7a23d6","signatureHash32":"0x9a7a23d69e77f6f530abfa14ee34b4a9eca620bc2fa8a7e70358a6565de3f5a1"},{"signature":"setFeeAddress(address,address)","signatureHash4":"0x61b3980d","signatureHash32":"0x61b3980d93d7d9390fa4c02e11e05d45f1e434443db038c6c91f93657becd598"},{"signature":"setFee(uint256,uint256)","signatureHash4":"0x52f7c988","signatureHash32":"0x52f7c9887a370373cd36b1a30311e967055bab800ef334814578c3deb534b80d"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"tokenAid()","signatureHash4":"0x8041f675","signatureHash32":"0x8041f675f1fd640f3ba7ba1e1331ca8f59087d17412a649cf965042a4b936c6e"},{"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":"uniswapV2PairAid()","signatureHash4":"0x8f3b7a3b","signatureHash32":"0x8f3b7a3b8e72f6343ea61cd8764fef786415ff82cf0266ae070c8167034a6c20"},{"signature":"uniswapV2Router()","signatureHash4":"0x1694505e","signatureHash32":"0x1694505e5e4acd84d3ad8a6f9903fdaf60e47d172a867ebf1cc6017c1f862119"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"56","address":"0xaE04AE29bdB7aB7Eb249d3aFa7Bc3D37564e8Cf9"}