{"matchId":"43721356","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-08-17T12:00:39Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"40397:619:0:-:0;;;40499:202;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40559:4;40565:6;9311:5;:13;40559:4;9311:5;:13;:::i;:::-;-1:-1:-1;9334:7:0;:17;9344:7;9334;:17;:::i;:::-;;9245:113;;2093:32;2112:12;:10;;;:12;;:::i;:::-;2093:18;:32::i;:::-;40584:7:::1;:20:::0;;-1:-1:-1;;;;;;40584:20:0::1;40594:10;40584:20;::::0;;40635:2:::1;40648:45;40654:7;2430:6:::0;;-1:-1:-1;;;;;2430:6:0;;2358:85;40654:7:::1;40677:15;40683:9:::0;40677:2:::1;:15;:::i;:::-;40663:29;::::0;:11:::1;:29;:::i;:::-;40648:5;:45::i;:::-;40573:128;40499:202:::0;;40397:619;;827:96;906:10;;827:96::o;3583:187::-;3675:6;;;-1:-1:-1;;;;;3691:17:0;;;-1:-1:-1;;;;;;3691:17:0;;;;;;;3723:40;;3675:6;;;3691:17;3675:6;;3723:40;;3656:16;;3723:40;3646:124;3583:187;:::o;15785:535::-;-1:-1:-1;;;;;15868:21:0;;15860:65;;;;-1:-1:-1;;;15860:65:0;;6037:2:1;15860:65:0;;;6019:21:1;6076:2;6056:18;;;6049:30;6115:33;6095:18;;;6088:61;6166:18;;15860:65:0;;;;;;;;16012:6;15996:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;16164:18:0;;:9;:18;;;;;;;;;;;:28;;;;;;16217:37;6471:25:1;;;16217:37:0;;6444:18:1;16217:37:0;;;;;;;15785:535;;:::o;19338:91::-;;;;:::o;14:127:1:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:840;200:5;253:3;246:4;238:6;234:17;230:27;220:55;;271:1;268;261:12;220:55;294:13;;-1:-1:-1;;;;;356:10:1;;;353:36;;;369:18;;:::i;:::-;444:2;438:9;412:2;498:13;;-1:-1:-1;;494:22:1;;;518:2;490:31;486:40;474:53;;;542:18;;;562:22;;;539:46;536:72;;;588:18;;:::i;:::-;628:10;624:2;617:22;663:2;655:6;648:18;685:4;675:14;;730:3;725:2;720;712:6;708:15;704:24;701:33;698:53;;;747:1;744;737:12;698:53;769:1;760:10;;779:133;793:2;790:1;787:9;779:133;;;881:14;;;877:23;;871:30;850:14;;;846:23;;839:63;804:10;;;;779:133;;;954:1;932:15;;;928:24;;;921:35;;;;936:6;146:840;-1:-1:-1;;;;146:840:1:o;991:562::-;1090:6;1098;1151:2;1139:9;1130:7;1126:23;1122:32;1119:52;;;1167:1;1164;1157:12;1119:52;1194:16;;-1:-1:-1;;;;;1259:14:1;;;1256:34;;;1286:1;1283;1276:12;1256:34;1309:61;1362:7;1353:6;1342:9;1338:22;1309:61;:::i;:::-;1299:71;;1416:2;1405:9;1401:18;1395:25;1379:41;;1445:2;1435:8;1432:16;1429:36;;;1461:1;1458;1451:12;1429:36;;1484:63;1539:7;1528:8;1517:9;1513:24;1484:63;:::i;:::-;1474:73;;;991:562;;;;;:::o;1558:380::-;1637:1;1633:12;;;;1680;;;1701:61;;1755:4;1747:6;1743:17;1733:27;;1701:61;1808:2;1800:6;1797:14;1777:18;1774:38;1771:161;;1854:10;1849:3;1845:20;1842:1;1835:31;1889:4;1886:1;1879:15;1917:4;1914:1;1907:15;1771:161;;1558:380;;;:::o;2069:545::-;2171:2;2166:3;2163:11;2160:448;;;2207:1;2232:5;2228:2;2221:17;2277:4;2273:2;2263:19;2347:2;2335:10;2331:19;2328:1;2324:27;2318:4;2314:38;2383:4;2371:10;2368:20;2365:47;;;-1:-1:-1;2406:4:1;2365:47;2461:2;2456:3;2452:12;2449:1;2445:20;2439:4;2435:31;2425:41;;2516:82;2534:2;2527:5;2524:13;2516:82;;;2579:17;;;2560:1;2549:13;2516:82;;;2520:3;;;2069:545;;;:::o;2790:1352::-;2910:10;;-1:-1:-1;;;;;2932:30:1;;2929:56;;;2965:18;;:::i;:::-;2994:97;3084:6;3044:38;3076:4;3070:11;3044:38;:::i;:::-;3038:4;2994:97;:::i;:::-;3146:4;;3210:2;3199:14;;3227:1;3222:663;;;;3929:1;3946:6;3943:89;;;-1:-1:-1;3998:19:1;;;3992:26;3943:89;-1:-1:-1;;2747:1:1;2743:11;;;2739:24;2735:29;2725:40;2771:1;2767:11;;;2722:57;4045:81;;3192:944;;3222:663;2016:1;2009:14;;;2053:4;2040:18;;-1:-1:-1;;3258:20:1;;;3376:236;3390:7;3387:1;3384:14;3376:236;;;3479:19;;;3473:26;3458:42;;3571:27;;;;3539:1;3527:14;;;;3406:19;;3376:236;;;3380:3;3640:6;3631:7;3628:19;3625:201;;;3701:19;;;3695:26;-1:-1:-1;;3784:1:1;3780:14;;;3796:3;3776:24;3772:37;3768:42;3753:58;3738:74;;3625:201;-1:-1:-1;;;;;3872:1:1;3856:14;;;3852:22;3839:36;;-1:-1:-1;2790:1352:1:o;4147:127::-;4208:10;4203:3;4199:20;4196:1;4189:31;4239:4;4236:1;4229:15;4263:4;4260:1;4253:15;4279:422;4368:1;4411:5;4368:1;4425:270;4446:7;4436:8;4433:21;4425:270;;;4505:4;4501:1;4497:6;4493:17;4487:4;4484:27;4481:53;;;4514:18;;:::i;:::-;4564:7;4554:8;4550:22;4547:55;;;4584:16;;;;4547:55;4663:22;;;;4623:15;;;;4425:270;;;4429:3;4279:422;;;;;:::o;4706:806::-;4755:5;4785:8;4775:80;;-1:-1:-1;4826:1:1;4840:5;;4775:80;4874:4;4864:76;;-1:-1:-1;4911:1:1;4925:5;;4864:76;4956:4;4974:1;4969:59;;;;5042:1;5037:130;;;;4949:218;;4969:59;4999:1;4990:10;;5013:5;;;5037:130;5074:3;5064:8;5061:17;5058:43;;;5081:18;;:::i;:::-;-1:-1:-1;;5137:1:1;5123:16;;5152:5;;4949:218;;5251:2;5241:8;5238:16;5232:3;5226:4;5223:13;5219:36;5213:2;5203:8;5200:16;5195:2;5189:4;5186:12;5182:35;5179:77;5176:159;;;-1:-1:-1;5288:19:1;;;5320:5;;5176:159;5367:34;5392:8;5386:4;5367:34;:::i;:::-;5437:6;5433:1;5429:6;5425:19;5416:7;5413:32;5410:58;;;5448:18;;:::i;:::-;5486:20;;-1:-1:-1;4706:806:1;;;;;:::o;5517:140::-;5575:5;5604:47;5645:4;5635:8;5631:19;5625:4;5604:47;:::i;:::-;5595:56;5517:140;-1:-1:-1;;;5517:140:1:o;5662:168::-;5735:9;;;5766;;5783:15;;;5777:22;;5763:37;5753:71;;5804:18;;:::i;6195:125::-;6260:9;;;6281:10;;;6278:36;;;6294:18;;:::i;6325:177::-;40397:619:0;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212201dfb4044c2eda8c142ea5b7ea35a28bdc7c4ab9c9ef0dd693800bbc73653f13a64736f6c63430008120033","offset":5513}},"transformations":[{"id":"1","type":"replace","offset":5513,"reason":"cborAuxdata"},{"type":"insert","offset":5566,"reason":"constructorArguments"}],"transformationValues":{"cborAuxdata":{"1":"0xa2646970667358221220d181716e49703a528f63a89c396c228808a0cc3e67fa92631062dc5cfe721de764736f6c63430008120033"},"constructorArguments":"0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000003414943000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034149430000000000000000000000000000000000000000000000000000000000"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"40397:619:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9423:98;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11709:197;;;;;;;;;;-1:-1:-1;11709:197:0;;;;;:::i;:::-;;:::i;:::-;;;1272:14:1;;1265:22;1247:41;;1235:2;1220:18;11709:197:0;1107:187:1;10520:106:0;;;;;;;;;;-1:-1:-1;10607:12:0;;10520:106;;;1445:25:1;;;1433:2;1418:18;10520:106:0;1299:177:1;12468:256:0;;;;;;;;;;-1:-1:-1;12468:256:0;;;;;:::i;:::-;;:::i;10369:91::-;;;;;;;;;;-1:-1:-1;10369:91:0;;10451:2;1956:36:1;;1944:2;1929:18;10369:91:0;1814:184:1;13119:234:0;;;;;;;;;;-1:-1:-1;13119:234:0;;;;;:::i;:::-;;:::i;10684:125::-;;;;;;;;;;-1:-1:-1;10684:125:0;;;;;:::i;:::-;-1:-1:-1;;;;;10784:18:0;10758:7;10784:18;;;;;;;;;;;;10684:125;2981:101;;;;;;;;;;;;;:::i;:::-;;2358:85;;;;;;;;;;-1:-1:-1;2430:6:0;;-1:-1:-1;;;;;2430:6:0;2358:85;;;-1:-1:-1;;;;;2358:32:1;;;2340:51;;2328:2;2313:18;2358:85:0;2194:203:1;9634:102:0;;;;;;;;;;;;;:::i;13840:427::-;;;;;;;;;;-1:-1:-1;13840:427:0;;;;;:::i;:::-;;:::i;11005:189::-;;;;;;;;;;-1:-1:-1;11005:189:0;;;;;:::i;:::-;;:::i;40468:22::-;;;;;;;;;;-1:-1:-1;40468:22:0;;;;-1:-1:-1;;;;;40468:22:0;;;11252:149;;;;;;;;;;-1:-1:-1;11252:149:0;;;;;:::i;:::-;;:::i;3231:198::-;;;;;;;;;;-1:-1:-1;3231:198:0;;;;;:::i;:::-;;:::i;40746:267::-;;;;;;;;;;-1:-1:-1;40746:267:0;;;;;:::i;:::-;;:::i;9423:98::-;9477:13;9509:5;9502:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9423:98;:::o;11709:197::-;11792:4;906:10;11846:32;906:10;11862:7;11871:6;11846:8;:32::i;:::-;11895:4;11888:11;;;11709:197;;;;;:::o;12468:256::-;12565:4;906:10;12621:38;12637:4;906:10;12652:6;12621:15;:38::i;:::-;12669:27;12679:4;12685:2;12689:6;12669:9;:27::i;:::-;-1:-1:-1;12713:4:0;;12468:256;-1:-1:-1;;;;12468:256:0:o;13119:234::-;13207:4;906:10;13261:64;906:10;13277:7;13314:10;13286:25;906:10;13277:7;13286:9;:25::i;:::-;:38;;;;:::i;:::-;13261:8;:64::i;2981:101::-;2251:13;:11;:13::i;:::-;3045:30:::1;3072:1;3045:18;:30::i;:::-;2981:101::o:0;9634:102::-;9690:13;9722:7;9715:14;;;;;:::i;13840:427::-;13933:4;906:10;13933:4;14014:25;906:10;14031:7;14014:9;:25::i;:::-;13987:52;;14077:15;14057:16;:35;;14049:85;;;;-1:-1:-1;;;14049:85:0;;3481:2:1;14049:85:0;;;3463:21:1;3520:2;3500:18;;;3493:30;3559:34;3539:18;;;3532:62;-1:-1:-1;;;3610:18:1;;;3603:35;3655:19;;14049:85:0;;;;;;;;;14168:60;14177:5;14184:7;14212:15;14193:16;:34;14168:8;:60::i;11005:189::-;11084:4;906:10;11138:28;906:10;11155:2;11159:6;11138:9;:28::i;11252:149::-;-1:-1:-1;;;;;11367:18:0;;;11341:7;11367:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;11252:149::o;3231:198::-;2251:13;:11;:13::i;:::-;-1:-1:-1;;;;;3319:22:0;::::1;3311:73;;;::::0;-1:-1:-1;;;3311:73:0;;3887:2:1;3311:73:0::1;::::0;::::1;3869:21:1::0;3926:2;3906:18;;;3899:30;3965:34;3945:18;;;3938:62;-1:-1:-1;;;4016:18:1;;;4009:36;4062:19;;3311:73:0::1;3685:402:1::0;3311:73:0::1;3394:28;3413:8;3394:18;:28::i;:::-;3231:198:::0;:::o;40746:267::-;40834:7;;40808:58;;-1:-1:-1;;;;;40834:7:0;40844:21;40808:17;:58::i;:::-;-1:-1:-1;;;;;40881:20:0;;;40877:129;;40945:7;;40954:39;;-1:-1:-1;;;40954:39:0;;40987:4;40954:39;;;2340:51:1;40917:77:0;;-1:-1:-1;;;;;40945:7:0;;;;40954:24;;;;;;2313:18:1;;40954:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;40917:27:0;;;:77;:27;:77::i;17722:340::-;-1:-1:-1;;;;;17823:19:0;;17815:68;;;;-1:-1:-1;;;17815:68:0;;4483:2:1;17815:68:0;;;4465:21:1;4522:2;4502:18;;;4495:30;4561:34;4541:18;;;4534:62;-1:-1:-1;;;4612:18:1;;;4605:34;4656:19;;17815:68:0;4281:400:1;17815:68:0;-1:-1:-1;;;;;17901:21:0;;17893:68;;;;-1:-1:-1;;;17893:68:0;;4888:2:1;17893:68:0;;;4870:21:1;4927:2;4907:18;;;4900:30;4966:34;4946:18;;;4939:62;-1:-1:-1;;;5017:18:1;;;5010:32;5059:19;;17893:68:0;4686:398:1;17893:68:0;-1:-1:-1;;;;;17972:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;18023:32;;1445:25:1;;;18023:32:0;;1418:18:1;18023:32:0;;;;;;;17722:340;;;:::o;18343:411::-;18443:24;18470:25;18480:5;18487:7;18470:9;:25::i;:::-;18443:52;;-1:-1:-1;;18509:16:0;:37;18505:243;;18590:6;18570:16;:26;;18562:68;;;;-1:-1:-1;;;18562:68:0;;5291:2:1;18562:68:0;;;5273:21:1;5330:2;5310:18;;;5303:30;5369:31;5349:18;;;5342:59;5418:18;;18562:68:0;5089:353:1;18562:68:0;18672:51;18681:5;18688:7;18716:6;18697:16;:25;18672:8;:51::i;:::-;18433:321;18343:411;;;:::o;14721:788::-;-1:-1:-1;;;;;14817:18:0;;14809:68;;;;-1:-1:-1;;;14809:68:0;;5649:2:1;14809:68:0;;;5631:21:1;5688:2;5668:18;;;5661:30;5727:34;5707:18;;;5700:62;-1:-1:-1;;;5778:18:1;;;5771:35;5823:19;;14809:68:0;5447:401:1;14809:68:0;-1:-1:-1;;;;;14895:16:0;;14887:64;;;;-1:-1:-1;;;14887:64:0;;6055:2:1;14887:64:0;;;6037:21:1;6094:2;6074:18;;;6067:30;6133:34;6113:18;;;6106:62;-1:-1:-1;;;6184:18:1;;;6177:33;6227:19;;14887:64:0;5853:399:1;14887:64:0;-1:-1:-1;;;;;15033:15:0;;15011:19;15033:15;;;;;;;;;;;15066:21;;;;15058:72;;;;-1:-1:-1;;;15058:72:0;;6459:2:1;15058:72:0;;;6441:21:1;6498:2;6478:18;;;6471:30;6537:34;6517:18;;;6510:62;-1:-1:-1;;;6588:18:1;;;6581:36;6634:19;;15058:72:0;6257:402:1;15058:72:0;-1:-1:-1;;;;;15164:15:0;;;:9;:15;;;;;;;;;;;15182:20;;;15164:38;;15379:13;;;;;;;;;;:23;;;;;;15428:26;;1445:25:1;;;15379:13:0;;15428:26;;1418:18:1;15428:26:0;;;;;;;15465:37;26689:312;2516:130;2430:6;;-1:-1:-1;;;;;2430:6:0;906:10;2579:23;2571:68;;;;-1:-1:-1;;;2571:68:0;;6866:2:1;2571:68:0;;;6848:21:1;;;6885:18;;;6878:30;6944:34;6924:18;;;6917:62;6996:18;;2571:68:0;6664:356:1;3583:187:0;3675:6;;;-1:-1:-1;;;;;3691:17:0;;;-1:-1:-1;;;;;;3691:17:0;;;;;;;3723:40;;3675:6;;;3691:17;3675:6;;3723:40;;3656:16;;3723:40;3646:124;3583:187;:::o;26689:312::-;26803:6;26778:21;:31;;26770:73;;;;-1:-1:-1;;;26770:73:0;;7227:2:1;26770:73:0;;;7209:21:1;7266:2;7246:18;;;7239:30;7305:31;7285:18;;;7278:59;7354:18;;26770:73:0;7025:353:1;26770:73:0;26855:12;26873:9;-1:-1:-1;;;;;26873:14:0;26895:6;26873:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26854:52;;;26924:7;26916:78;;;;-1:-1:-1;;;26916:78:0;;7795:2:1;26916:78:0;;;7777:21:1;7834:2;7814:18;;;7807:30;7873:34;7853:18;;;7846:62;7944:28;7924:18;;;7917:56;7990:19;;26916:78:0;7593:422:1;26916:78:0;26760:241;26689:312;;:::o;34314:175::-;34423:58;;;-1:-1:-1;;;;;8212:32:1;;;34423:58:0;;;8194:51:1;8261:18;;;;8254:34;;;34423:58:0;;;;;;;;;;8167:18:1;;;;34423:58:0;;;;;;;;-1:-1:-1;;;;;34423:58:0;-1:-1:-1;;;34423:58:0;;;39014:69;;;;;;;;;;;;;;;;34396:86;;34416:5;;34423:58;-1:-1:-1;;39014:69:0;;:27;;;34423:58;;39014:27;:69::i;:::-;38988:95;;39101:10;:17;39122:1;39101:22;:56;;;;39138:10;39127:30;;;;;;;;;;;;:::i;:::-;39093:111;;;;-1:-1:-1;;;39093:111:0;;8783:2:1;39093:111:0;;;8765:21:1;8822:2;8802:18;;;8795:30;8861:34;8841:18;;;8834:62;-1:-1:-1;;;8912:18:1;;;8905:40;8962:19;;39093:111:0;8581:406:1;28150:223:0;28283:12;28314:52;28336:6;28344:4;28350:1;28353:12;28314:21;:52::i;:::-;28307:59;28150:223;-1:-1:-1;;;;28150:223:0:o;29207:446::-;29372:12;29429:5;29404:21;:30;;29396:81;;;;-1:-1:-1;;;29396:81:0;;9194:2:1;29396:81:0;;;9176:21:1;9233:2;9213:18;;;9206:30;9272:34;9252:18;;;9245:62;-1:-1:-1;;;9323:18:1;;;9316:36;9369:19;;29396:81:0;8992:402:1;29396:81:0;29488:12;29502:23;29529:6;-1:-1:-1;;;;;29529:11:0;29548:5;29555:4;29529:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29487:73;;;;29577:69;29604:6;29612:7;29621:10;29633:12;29577:26;:69::i;:::-;29570:76;29207:446;-1:-1:-1;;;;;;;29207:446:0:o;31713:628::-;31893:12;31921:7;31917:418;;;31948:10;:17;31969:1;31948:22;31944:286;;-1:-1:-1;;;;;25744:19:0;;;32155:60;;;;-1:-1:-1;;;32155:60:0;;9893:2:1;32155:60:0;;;9875:21:1;9932:2;9912:18;;;9905:30;9971:31;9951:18;;;9944:59;10020:18;;32155:60:0;9691:353:1;32155:60:0;-1:-1:-1;32250:10:0;32243:17;;31917:418;32291:33;32299:10;32311:12;33022:17;;:21;33018:379;;33250:10;33244:17;33306:15;33293:10;33289:2;33285:19;33278:44;33018:379;33373:12;33366:20;;-1:-1:-1;;;33366: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;1481:328::-;1558:6;1566;1574;1627:2;1615:9;1606:7;1602:23;1598:32;1595:52;;;1643:1;1640;1633:12;1595:52;1666:29;1685:9;1666:29;:::i;:::-;1656:39;;1714:38;1748:2;1737:9;1733:18;1714:38;:::i;:::-;1704:48;;1799:2;1788:9;1784:18;1771:32;1761:42;;1481:328;;;;;:::o;2003:186::-;2062:6;2115:2;2103:9;2094:7;2090:23;2086:32;2083:52;;;2131:1;2128;2121:12;2083:52;2154:29;2173:9;2154:29;:::i;:::-;2144:39;2003:186;-1:-1:-1;;;2003:186:1:o;2402:260::-;2470:6;2478;2531:2;2519:9;2510:7;2506:23;2502:32;2499:52;;;2547:1;2544;2537:12;2499:52;2570:29;2589:9;2570:29;:::i;:::-;2560:39;;2618:38;2652:2;2641:9;2637:18;2618:38;:::i;:::-;2608:48;;2402:260;;;;;:::o;2667:380::-;2746:1;2742:12;;;;2789;;;2810:61;;2864:4;2856:6;2852:17;2842:27;;2810:61;2917:2;2909:6;2906:14;2886:18;2883:38;2880:161;;2963:10;2958:3;2954:20;2951:1;2944:31;2998:4;2995:1;2988:15;3026:4;3023:1;3016:15;2880:161;;2667:380;;;:::o;3052:222::-;3117:9;;;3138:10;;;3135:133;;;3190:10;3185:3;3181:20;3178:1;3171:31;3225:4;3222:1;3215:15;3253:4;3250:1;3243:15;4092:184;4162:6;4215:2;4203:9;4194:7;4190:23;4186:32;4183:52;;;4231:1;4228;4221:12;4183:52;-1:-1:-1;4254:16:1;;4092:184;-1:-1:-1;4092:184:1:o;8299:277::-;8366:6;8419:2;8407:9;8398:7;8394:23;8390:32;8387:52;;;8435:1;8432;8425:12;8387:52;8467:9;8461:16;8520:5;8513:13;8506:21;8499:5;8496:32;8486:60;;8542:1;8539;8532:12;9399:287;9528:3;9566:6;9560:13;9582:66;9641:6;9636:3;9629:4;9621:6;9617:17;9582:66;:::i;:::-;9664:16;;;;;9399:287;-1:-1:-1;;9399:287:1:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212201dfb4044c2eda8c142ea5b7ea35a28bdc7c4ab9c9ef0dd693800bbc73653f13a64736f6c63430008120033","offset":4011}},"immutableReferences":{},"transformations":[{"id":"1","type":"replace","offset":4011,"reason":"cborAuxdata"}],"transformationValues":{"cborAuxdata":{"1":"0xa2646970667358221220d181716e49703a528f63a89c396c228808a0cc3e67fa92631062dc5cfe721de764736f6c63430008120033"}}},"deployment":{"transactionHash":"0x00b3fde6a293c628c0a23db5fb0aef2e2e033a5e146e8def94f9efa8ad1d57b2","blockNumber":"104663223","transactionIndex":"40","deployer":"0x13b81C2e8a4EDD2aAc1A096889B778103b16F7e8"},"sources":{"contracts/flatten/nexus_aic.sol":{"content":"// Sources flattened with hardhat v2.28.6 https://hardhat.org\n\n// SPDX-License-Identifier: MIT\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 contracts/nexus/1_aic.sol\n\n// Original license: SPDX_License_Identifier: MIT\r\ncontract AIC is ERC20, Ownable {\r\n    using SafeERC20 for IERC20;\r\n    address public devAddr;\r\n\r\n    constructor(string memory name, string memory symbol) ERC20(name, symbol) {\r\n        devAddr = msg.sender;\r\n\r\n        uint8 _decimals = 18;\r\n        _mint(owner(), 210_000_000 * 10 ** _decimals);\r\n    }\r\n\r\n    receive() external payable {}\r\n\r\n    function claimStuckTokens(address _token) external {\r\n        Address.sendValue(payable(devAddr), address(this).balance);\r\n        if (_token != address(0)){\r\n            IERC20(_token).safeTransfer(devAddr, IERC20(_token).balanceOf(address(this)));\r\n        }\r\n    }\r\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.18+commit.87f61d96","compilerSettings":{"optimizer":{"runs":200,"enabled":true}},"name":"AIC","fullyQualifiedName":"contracts/flatten/nexus_aic.sol:AIC"},"abi":[{"type":"constructor","inputs":[{"name":"name","type":"string","internalType":"string"},{"name":"symbol","type":"string","internalType":"string"}],"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":"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":"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":"devAddr","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":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.18+commit.87f61d96"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"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":"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":"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":"devAddr","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":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"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":{},"version":1}},"settings":{"compilationTarget":{"contracts/flatten/nexus_aic.sol":"AIC"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"contracts/flatten/nexus_aic.sol":{"keccak256":"0x430fbc23c8818d16b294790010ec00a5dfd64838c2a2f6c617197738100c5fff","license":"MIT","urls":["bzz-raw://8d842c02026cef924b3c6db673cc867686545b227ab31a8e0919a6761eec072a","dweb:/ipfs/QmSA82QvG18EzJL7vxsQbjhX6n8Aa26WRN9s3bLHDuj2ms"]}},"version":1},"storageLayout":{"types":{"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_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_aic.sol:AIC"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":254,"label":"_allowances","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"2","type":"t_uint256","astId":256,"label":"_totalSupply","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"3","type":"t_string_storage","astId":258,"label":"_name","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"4","type":"t_string_storage","astId":260,"label":"_symbol","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"5","type":"t_address","astId":34,"label":"_owner","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"6","type":"t_address","astId":1562,"label":"devAddr","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"sourceIds":{"contracts/flatten/nexus_aic.sol":{"id":0}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/flatten/nexus_aic.sol":{"content":"// Sources flattened with hardhat v2.28.6 https://hardhat.org\n\n// SPDX-License-Identifier: MIT\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 contracts/nexus/1_aic.sol\n\n// Original license: SPDX_License_Identifier: MIT\r\ncontract AIC is ERC20, Ownable {\r\n    using SafeERC20 for IERC20;\r\n    address public devAddr;\r\n\r\n    constructor(string memory name, string memory symbol) ERC20(name, symbol) {\r\n        devAddr = msg.sender;\r\n\r\n        uint8 _decimals = 18;\r\n        _mint(owner(), 210_000_000 * 10 ** _decimals);\r\n    }\r\n\r\n    receive() external payable {}\r\n\r\n    function claimStuckTokens(address _token) external {\r\n        Address.sendValue(payable(devAddr), address(this).balance);\r\n        if (_token != address(0)){\r\n            IERC20(_token).safeTransfer(devAddr, IERC20(_token).balanceOf(address(this)));\r\n        }\r\n    }\r\n}\n"}},"language":"Solidity","settings":{"optimizer":{"runs":200,"enabled":true}}},"stdJsonOutput":{"sources":{"contracts/flatten/nexus_aic.sol":{"id":0}},"contracts":{"contracts/flatten/nexus_aic.sol":{"AIC":{"abi":[{"type":"constructor","inputs":[{"name":"name","type":"string","internalType":"string"},{"name":"symbol","type":"string","internalType":"string"}],"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":"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":"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":"devAddr","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":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.18+commit.87f61d96\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"}],\"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\":\"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\":\"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\":\"devAddr\",\"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\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"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\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/flatten/nexus_aic.sol\":\"AIC\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/flatten/nexus_aic.sol\":{\"keccak256\":\"0x430fbc23c8818d16b294790010ec00a5dfd64838c2a2f6c617197738100c5fff\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8d842c02026cef924b3c6db673cc867686545b227ab31a8e0919a6761eec072a\",\"dweb:/ipfs/QmSA82QvG18EzJL7vxsQbjhX6n8Aa26WRN9s3bLHDuj2ms\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"storageLayout":{"types":{"t_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_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_aic.sol:AIC"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":254,"label":"_allowances","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"2","type":"t_uint256","astId":256,"label":"_totalSupply","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"3","type":"t_string_storage","astId":258,"label":"_name","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"4","type":"t_string_storage","astId":260,"label":"_symbol","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"5","type":"t_address","astId":34,"label":"_owner","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"},{"slot":"6","type":"t_address","astId":1562,"label":"devAddr","offset":0,"contract":"contracts/flatten/nexus_aic.sol:AIC"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"40397:619:0:-:0;;;40499:202;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40559:4;40565:6;9311:5;:13;40559:4;9311:5;:13;:::i;:::-;-1:-1:-1;9334:7:0;:17;9344:7;9334;:17;:::i;:::-;;9245:113;;2093:32;2112:12;:10;;;:12;;:::i;:::-;2093:18;:32::i;:::-;40584:7:::1;:20:::0;;-1:-1:-1;;;;;;40584:20:0::1;40594:10;40584:20;::::0;;40635:2:::1;40648:45;40654:7;2430:6:::0;;-1:-1:-1;;;;;2430:6:0;;2358:85;40654:7:::1;40677:15;40683:9:::0;40677:2:::1;:15;:::i;:::-;40663:29;::::0;:11:::1;:29;:::i;:::-;40648:5;:45::i;:::-;40573:128;40499:202:::0;;40397:619;;827:96;906:10;;827:96::o;3583:187::-;3675:6;;;-1:-1:-1;;;;;3691:17:0;;;-1:-1:-1;;;;;;3691:17:0;;;;;;;3723:40;;3675:6;;;3691:17;3675:6;;3723:40;;3656:16;;3723:40;3646:124;3583:187;:::o;15785:535::-;-1:-1:-1;;;;;15868:21:0;;15860:65;;;;-1:-1:-1;;;15860:65:0;;6037:2:1;15860:65:0;;;6019:21:1;6076:2;6056:18;;;6049:30;6115:33;6095:18;;;6088:61;6166:18;;15860:65:0;;;;;;;;16012:6;15996:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;16164:18:0;;:9;:18;;;;;;;;;;;:28;;;;;;16217:37;6471:25:1;;;16217:37:0;;6444:18:1;16217:37:0;;;;;;;15785:535;;:::o;19338:91::-;;;;:::o;14:127:1:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:840;200:5;253:3;246:4;238:6;234:17;230:27;220:55;;271:1;268;261:12;220:55;294:13;;-1:-1:-1;;;;;356:10:1;;;353:36;;;369:18;;:::i;:::-;444:2;438:9;412:2;498:13;;-1:-1:-1;;494:22:1;;;518:2;490:31;486:40;474:53;;;542:18;;;562:22;;;539:46;536:72;;;588:18;;:::i;:::-;628:10;624:2;617:22;663:2;655:6;648:18;685:4;675:14;;730:3;725:2;720;712:6;708:15;704:24;701:33;698:53;;;747:1;744;737:12;698:53;769:1;760:10;;779:133;793:2;790:1;787:9;779:133;;;881:14;;;877:23;;871:30;850:14;;;846:23;;839:63;804:10;;;;779:133;;;954:1;932:15;;;928:24;;;921:35;;;;936:6;146:840;-1:-1:-1;;;;146:840:1:o;991:562::-;1090:6;1098;1151:2;1139:9;1130:7;1126:23;1122:32;1119:52;;;1167:1;1164;1157:12;1119:52;1194:16;;-1:-1:-1;;;;;1259:14:1;;;1256:34;;;1286:1;1283;1276:12;1256:34;1309:61;1362:7;1353:6;1342:9;1338:22;1309:61;:::i;:::-;1299:71;;1416:2;1405:9;1401:18;1395:25;1379:41;;1445:2;1435:8;1432:16;1429:36;;;1461:1;1458;1451:12;1429:36;;1484:63;1539:7;1528:8;1517:9;1513:24;1484:63;:::i;:::-;1474:73;;;991:562;;;;;:::o;1558:380::-;1637:1;1633:12;;;;1680;;;1701:61;;1755:4;1747:6;1743:17;1733:27;;1701:61;1808:2;1800:6;1797:14;1777:18;1774:38;1771:161;;1854:10;1849:3;1845:20;1842:1;1835:31;1889:4;1886:1;1879:15;1917:4;1914:1;1907:15;1771:161;;1558:380;;;:::o;2069:545::-;2171:2;2166:3;2163:11;2160:448;;;2207:1;2232:5;2228:2;2221:17;2277:4;2273:2;2263:19;2347:2;2335:10;2331:19;2328:1;2324:27;2318:4;2314:38;2383:4;2371:10;2368:20;2365:47;;;-1:-1:-1;2406:4:1;2365:47;2461:2;2456:3;2452:12;2449:1;2445:20;2439:4;2435:31;2425:41;;2516:82;2534:2;2527:5;2524:13;2516:82;;;2579:17;;;2560:1;2549:13;2516:82;;;2520:3;;;2069:545;;;:::o;2790:1352::-;2910:10;;-1:-1:-1;;;;;2932:30:1;;2929:56;;;2965:18;;:::i;:::-;2994:97;3084:6;3044:38;3076:4;3070:11;3044:38;:::i;:::-;3038:4;2994:97;:::i;:::-;3146:4;;3210:2;3199:14;;3227:1;3222:663;;;;3929:1;3946:6;3943:89;;;-1:-1:-1;3998:19:1;;;3992:26;3943:89;-1:-1:-1;;2747:1:1;2743:11;;;2739:24;2735:29;2725:40;2771:1;2767:11;;;2722:57;4045:81;;3192:944;;3222:663;2016:1;2009:14;;;2053:4;2040:18;;-1:-1:-1;;3258:20:1;;;3376:236;3390:7;3387:1;3384:14;3376:236;;;3479:19;;;3473:26;3458:42;;3571:27;;;;3539:1;3527:14;;;;3406:19;;3376:236;;;3380:3;3640:6;3631:7;3628:19;3625:201;;;3701:19;;;3695:26;-1:-1:-1;;3784:1:1;3780:14;;;3796:3;3776:24;3772:37;3768:42;3753:58;3738:74;;3625:201;-1:-1:-1;;;;;3872:1:1;3856:14;;;3852:22;3839:36;;-1:-1:-1;2790:1352:1:o;4147:127::-;4208:10;4203:3;4199:20;4196:1;4189:31;4239:4;4236:1;4229:15;4263:4;4260:1;4253:15;4279:422;4368:1;4411:5;4368:1;4425:270;4446:7;4436:8;4433:21;4425:270;;;4505:4;4501:1;4497:6;4493:17;4487:4;4484:27;4481:53;;;4514:18;;:::i;:::-;4564:7;4554:8;4550:22;4547:55;;;4584:16;;;;4547:55;4663:22;;;;4623:15;;;;4425:270;;;4429:3;4279:422;;;;;:::o;4706:806::-;4755:5;4785:8;4775:80;;-1:-1:-1;4826:1:1;4840:5;;4775:80;4874:4;4864:76;;-1:-1:-1;4911:1:1;4925:5;;4864:76;4956:4;4974:1;4969:59;;;;5042:1;5037:130;;;;4949:218;;4969:59;4999:1;4990:10;;5013:5;;;5037:130;5074:3;5064:8;5061:17;5058:43;;;5081:18;;:::i;:::-;-1:-1:-1;;5137:1:1;5123:16;;5152:5;;4949:218;;5251:2;5241:8;5238:16;5232:3;5226:4;5223:13;5219:36;5213:2;5203:8;5200:16;5195:2;5189:4;5186:12;5182:35;5179:77;5176:159;;;-1:-1:-1;5288:19:1;;;5320:5;;5176:159;5367:34;5392:8;5386:4;5367:34;:::i;:::-;5437:6;5433:1;5429:6;5425:19;5416:7;5413:32;5410:58;;;5448:18;;:::i;:::-;5486:20;;-1:-1:-1;4706:806:1;;;;;:::o;5517:140::-;5575:5;5604:47;5645:4;5635:8;5631:19;5625:4;5604:47;:::i;:::-;5595:56;5517:140;-1:-1:-1;;;5517:140:1:o;5662:168::-;5735:9;;;5766;;5783:15;;;5777:22;;5763:37;5753:71;;5804:18;;:::i;6195:125::-;6260:9;;;6281:10;;;6278:36;;;6294:18;;:::i;6325:177::-;40397:619:0;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"40397:619:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9423:98;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11709:197;;;;;;;;;;-1:-1:-1;11709:197:0;;;;;:::i;:::-;;:::i;:::-;;;1272:14:1;;1265:22;1247:41;;1235:2;1220:18;11709:197:0;1107:187:1;10520:106:0;;;;;;;;;;-1:-1:-1;10607:12:0;;10520:106;;;1445:25:1;;;1433:2;1418:18;10520:106:0;1299:177:1;12468:256:0;;;;;;;;;;-1:-1:-1;12468:256:0;;;;;:::i;:::-;;:::i;10369:91::-;;;;;;;;;;-1:-1:-1;10369:91:0;;10451:2;1956:36:1;;1944:2;1929:18;10369:91:0;1814:184:1;13119:234:0;;;;;;;;;;-1:-1:-1;13119:234:0;;;;;:::i;:::-;;:::i;10684:125::-;;;;;;;;;;-1:-1:-1;10684:125:0;;;;;:::i;:::-;-1:-1:-1;;;;;10784:18:0;10758:7;10784:18;;;;;;;;;;;;10684:125;2981:101;;;;;;;;;;;;;:::i;:::-;;2358:85;;;;;;;;;;-1:-1:-1;2430:6:0;;-1:-1:-1;;;;;2430:6:0;2358:85;;;-1:-1:-1;;;;;2358:32:1;;;2340:51;;2328:2;2313:18;2358:85:0;2194:203:1;9634:102:0;;;;;;;;;;;;;:::i;13840:427::-;;;;;;;;;;-1:-1:-1;13840:427:0;;;;;:::i;:::-;;:::i;11005:189::-;;;;;;;;;;-1:-1:-1;11005:189:0;;;;;:::i;:::-;;:::i;40468:22::-;;;;;;;;;;-1:-1:-1;40468:22:0;;;;-1:-1:-1;;;;;40468:22:0;;;11252:149;;;;;;;;;;-1:-1:-1;11252:149:0;;;;;:::i;:::-;;:::i;3231:198::-;;;;;;;;;;-1:-1:-1;3231:198:0;;;;;:::i;:::-;;:::i;40746:267::-;;;;;;;;;;-1:-1:-1;40746:267:0;;;;;:::i;:::-;;:::i;9423:98::-;9477:13;9509:5;9502:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9423:98;:::o;11709:197::-;11792:4;906:10;11846:32;906:10;11862:7;11871:6;11846:8;:32::i;:::-;11895:4;11888:11;;;11709:197;;;;;:::o;12468:256::-;12565:4;906:10;12621:38;12637:4;906:10;12652:6;12621:15;:38::i;:::-;12669:27;12679:4;12685:2;12689:6;12669:9;:27::i;:::-;-1:-1:-1;12713:4:0;;12468:256;-1:-1:-1;;;;12468:256:0:o;13119:234::-;13207:4;906:10;13261:64;906:10;13277:7;13314:10;13286:25;906:10;13277:7;13286:9;:25::i;:::-;:38;;;;:::i;:::-;13261:8;:64::i;2981:101::-;2251:13;:11;:13::i;:::-;3045:30:::1;3072:1;3045:18;:30::i;:::-;2981:101::o:0;9634:102::-;9690:13;9722:7;9715:14;;;;;:::i;13840:427::-;13933:4;906:10;13933:4;14014:25;906:10;14031:7;14014:9;:25::i;:::-;13987:52;;14077:15;14057:16;:35;;14049:85;;;;-1:-1:-1;;;14049:85:0;;3481:2:1;14049:85:0;;;3463:21:1;3520:2;3500:18;;;3493:30;3559:34;3539:18;;;3532:62;-1:-1:-1;;;3610:18:1;;;3603:35;3655:19;;14049:85:0;;;;;;;;;14168:60;14177:5;14184:7;14212:15;14193:16;:34;14168:8;:60::i;11005:189::-;11084:4;906:10;11138:28;906:10;11155:2;11159:6;11138:9;:28::i;11252:149::-;-1:-1:-1;;;;;11367:18:0;;;11341:7;11367:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;11252:149::o;3231:198::-;2251:13;:11;:13::i;:::-;-1:-1:-1;;;;;3319:22:0;::::1;3311:73;;;::::0;-1:-1:-1;;;3311:73:0;;3887:2:1;3311:73:0::1;::::0;::::1;3869:21:1::0;3926:2;3906:18;;;3899:30;3965:34;3945:18;;;3938:62;-1:-1:-1;;;4016:18:1;;;4009:36;4062:19;;3311:73:0::1;3685:402:1::0;3311:73:0::1;3394:28;3413:8;3394:18;:28::i;:::-;3231:198:::0;:::o;40746:267::-;40834:7;;40808:58;;-1:-1:-1;;;;;40834:7:0;40844:21;40808:17;:58::i;:::-;-1:-1:-1;;;;;40881:20:0;;;40877:129;;40945:7;;40954:39;;-1:-1:-1;;;40954:39:0;;40987:4;40954:39;;;2340:51:1;40917:77:0;;-1:-1:-1;;;;;40945:7:0;;;;40954:24;;;;;;2313:18:1;;40954:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;40917:27:0;;;:77;:27;:77::i;17722:340::-;-1:-1:-1;;;;;17823:19:0;;17815:68;;;;-1:-1:-1;;;17815:68:0;;4483:2:1;17815:68:0;;;4465:21:1;4522:2;4502:18;;;4495:30;4561:34;4541:18;;;4534:62;-1:-1:-1;;;4612:18:1;;;4605:34;4656:19;;17815:68:0;4281:400:1;17815:68:0;-1:-1:-1;;;;;17901:21:0;;17893:68;;;;-1:-1:-1;;;17893:68:0;;4888:2:1;17893:68:0;;;4870:21:1;4927:2;4907:18;;;4900:30;4966:34;4946:18;;;4939:62;-1:-1:-1;;;5017:18:1;;;5010:32;5059:19;;17893:68:0;4686:398:1;17893:68:0;-1:-1:-1;;;;;17972:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;18023:32;;1445:25:1;;;18023:32:0;;1418:18:1;18023:32:0;;;;;;;17722:340;;;:::o;18343:411::-;18443:24;18470:25;18480:5;18487:7;18470:9;:25::i;:::-;18443:52;;-1:-1:-1;;18509:16:0;:37;18505:243;;18590:6;18570:16;:26;;18562:68;;;;-1:-1:-1;;;18562:68:0;;5291:2:1;18562:68:0;;;5273:21:1;5330:2;5310:18;;;5303:30;5369:31;5349:18;;;5342:59;5418:18;;18562:68:0;5089:353:1;18562:68:0;18672:51;18681:5;18688:7;18716:6;18697:16;:25;18672:8;:51::i;:::-;18433:321;18343:411;;;:::o;14721:788::-;-1:-1:-1;;;;;14817:18:0;;14809:68;;;;-1:-1:-1;;;14809:68:0;;5649:2:1;14809:68:0;;;5631:21:1;5688:2;5668:18;;;5661:30;5727:34;5707:18;;;5700:62;-1:-1:-1;;;5778:18:1;;;5771:35;5823:19;;14809:68:0;5447:401:1;14809:68:0;-1:-1:-1;;;;;14895:16:0;;14887:64;;;;-1:-1:-1;;;14887:64:0;;6055:2:1;14887:64:0;;;6037:21:1;6094:2;6074:18;;;6067:30;6133:34;6113:18;;;6106:62;-1:-1:-1;;;6184:18:1;;;6177:33;6227:19;;14887:64:0;5853:399:1;14887:64:0;-1:-1:-1;;;;;15033:15:0;;15011:19;15033:15;;;;;;;;;;;15066:21;;;;15058:72;;;;-1:-1:-1;;;15058:72:0;;6459:2:1;15058:72:0;;;6441:21:1;6498:2;6478:18;;;6471:30;6537:34;6517:18;;;6510:62;-1:-1:-1;;;6588:18:1;;;6581:36;6634:19;;15058:72:0;6257:402:1;15058:72:0;-1:-1:-1;;;;;15164:15:0;;;:9;:15;;;;;;;;;;;15182:20;;;15164:38;;15379:13;;;;;;;;;;:23;;;;;;15428:26;;1445:25:1;;;15379:13:0;;15428:26;;1418:18:1;15428:26:0;;;;;;;15465:37;26689:312;2516:130;2430:6;;-1:-1:-1;;;;;2430:6:0;906:10;2579:23;2571:68;;;;-1:-1:-1;;;2571:68:0;;6866:2:1;2571:68:0;;;6848:21:1;;;6885:18;;;6878:30;6944:34;6924:18;;;6917:62;6996:18;;2571:68:0;6664:356:1;3583:187:0;3675:6;;;-1:-1:-1;;;;;3691:17:0;;;-1:-1:-1;;;;;;3691:17:0;;;;;;;3723:40;;3675:6;;;3691:17;3675:6;;3723:40;;3656:16;;3723:40;3646:124;3583:187;:::o;26689:312::-;26803:6;26778:21;:31;;26770:73;;;;-1:-1:-1;;;26770:73:0;;7227:2:1;26770:73:0;;;7209:21:1;7266:2;7246:18;;;7239:30;7305:31;7285:18;;;7278:59;7354:18;;26770:73:0;7025:353:1;26770:73:0;26855:12;26873:9;-1:-1:-1;;;;;26873:14:0;26895:6;26873:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26854:52;;;26924:7;26916:78;;;;-1:-1:-1;;;26916:78:0;;7795:2:1;26916:78:0;;;7777:21:1;7834:2;7814:18;;;7807:30;7873:34;7853:18;;;7846:62;7944:28;7924:18;;;7917:56;7990:19;;26916:78:0;7593:422:1;26916:78:0;26760:241;26689:312;;:::o;34314:175::-;34423:58;;;-1:-1:-1;;;;;8212:32:1;;;34423:58:0;;;8194:51:1;8261:18;;;;8254:34;;;34423:58:0;;;;;;;;;;8167:18:1;;;;34423:58:0;;;;;;;;-1:-1:-1;;;;;34423:58:0;-1:-1:-1;;;34423:58:0;;;39014:69;;;;;;;;;;;;;;;;34396:86;;34416:5;;34423:58;-1:-1:-1;;39014:69:0;;:27;;;34423:58;;39014:27;:69::i;:::-;38988:95;;39101:10;:17;39122:1;39101:22;:56;;;;39138:10;39127:30;;;;;;;;;;;;:::i;:::-;39093:111;;;;-1:-1:-1;;;39093:111:0;;8783:2:1;39093:111:0;;;8765:21:1;8822:2;8802:18;;;8795:30;8861:34;8841:18;;;8834:62;-1:-1:-1;;;8912:18:1;;;8905:40;8962:19;;39093:111:0;8581:406:1;28150:223:0;28283:12;28314:52;28336:6;28344:4;28350:1;28353:12;28314:21;:52::i;:::-;28307:59;28150:223;-1:-1:-1;;;;28150:223:0:o;29207:446::-;29372:12;29429:5;29404:21;:30;;29396:81;;;;-1:-1:-1;;;29396:81:0;;9194:2:1;29396:81:0;;;9176:21:1;9233:2;9213:18;;;9206:30;9272:34;9252:18;;;9245:62;-1:-1:-1;;;9323:18:1;;;9316:36;9369:19;;29396:81:0;8992:402:1;29396:81:0;29488:12;29502:23;29529:6;-1:-1:-1;;;;;29529:11:0;29548:5;29555:4;29529:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29487:73;;;;29577:69;29604:6;29612:7;29621:10;29633:12;29577:26;:69::i;:::-;29570:76;29207:446;-1:-1:-1;;;;;;;29207:446:0:o;31713:628::-;31893:12;31921:7;31917:418;;;31948:10;:17;31969:1;31948:22;31944:286;;-1:-1:-1;;;;;25744:19:0;;;32155:60;;;;-1:-1:-1;;;32155:60:0;;9893:2:1;32155:60:0;;;9875:21:1;9932:2;9912:18;;;9905:30;9971:31;9951:18;;;9944:59;10020:18;;32155:60:0;9691:353:1;32155:60:0;-1:-1:-1;32250:10:0;32243:17;;31917:418;32291:33;32299:10;32311:12;33022:17;;:21;33018:379;;33250:10;33244:17;33306:15;33293:10;33289:2;33285:19;33278:44;33018:379;33373:12;33366:20;;-1:-1:-1;;;33366: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;1481:328::-;1558:6;1566;1574;1627:2;1615:9;1606:7;1602:23;1598:32;1595:52;;;1643:1;1640;1633:12;1595:52;1666:29;1685:9;1666:29;:::i;:::-;1656:39;;1714:38;1748:2;1737:9;1733:18;1714:38;:::i;:::-;1704:48;;1799:2;1788:9;1784:18;1771:32;1761:42;;1481:328;;;;;:::o;2003:186::-;2062:6;2115:2;2103:9;2094:7;2090:23;2086:32;2083:52;;;2131:1;2128;2121:12;2083:52;2154:29;2173:9;2154:29;:::i;:::-;2144:39;2003:186;-1:-1:-1;;;2003:186:1:o;2402:260::-;2470:6;2478;2531:2;2519:9;2510:7;2506:23;2502:32;2499:52;;;2547:1;2544;2537:12;2499:52;2570:29;2589:9;2570:29;:::i;:::-;2560:39;;2618:38;2652:2;2641:9;2637:18;2618:38;:::i;:::-;2608:48;;2402:260;;;;;:::o;2667:380::-;2746:1;2742:12;;;;2789;;;2810:61;;2864:4;2856:6;2852:17;2842:27;;2810:61;2917:2;2909:6;2906:14;2886:18;2883:38;2880:161;;2963:10;2958:3;2954:20;2951:1;2944:31;2998:4;2995:1;2988:15;3026:4;3023:1;3016:15;2880:161;;2667:380;;;:::o;3052:222::-;3117:9;;;3138:10;;;3135:133;;;3190:10;3185:3;3181:20;3178:1;3171:31;3225:4;3222:1;3215:15;3253:4;3250:1;3243:15;4092:184;4162:6;4215:2;4203:9;4194:7;4190:23;4186:32;4183:52;;;4231:1;4228;4221:12;4183:52;-1:-1:-1;4254:16:1;;4092:184;-1:-1:-1;4092:184:1:o;8299:277::-;8366:6;8419:2;8407:9;8398:7;8394:23;8390:32;8387:52;;;8435:1;8432;8425:12;8387:52;8467:9;8461:16;8520:5;8513:13;8506:21;8499:5;8496:32;8486:60;;8542:1;8539;8532:12;9399:287;9528:3;9566:6;9560:13;9582:66;9641:6;9636:3;9629:4;9621:6;9617:17;9582:66;:::i;:::-;9664:16;;;;;9399:287;-1:-1:-1;;9399:287:1:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"claimStuckTokens(address)","signatureHash4":"0xf9d0831a","signatureHash32":"0xf9d0831a71895cdfc0fec981d39127e7ab103a991c0bd327d9003b710ec44a5a"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"decreaseAllowance(address,uint256)","signatureHash4":"0xa457c2d7","signatureHash32":"0xa457c2d77307f80ff2f3ac810ec99eb18ae2cffee13b29c90c9324546e374be5"},{"signature":"devAddr()","signatureHash4":"0xda09c72c","signatureHash32":"0xda09c72cb12522ac5cbad8d78e9976b5f5c543221698eacc133ffa160ef43503"},{"signature":"increaseAllowance(address,uint256)","signatureHash4":"0x39509351","signatureHash32":"0x39509351d3325647dde3fdd3c8b249adfe89ef4f16d76d83768e6df7a5cd81d6"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"}],"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":"0xc0DC449De632586A00409873521AFC251aC5cE74"}